This can only be invoked when the image has no alpha channel.
182 | * Calling this method causes {@link #hasAlpha()} to return true.
183 | *
184 | * @param r the red component of the color to make transparent
185 | * @param g the green component of the color to make transparent
186 | * @param b the blue component of the color to make transparent
187 | * @throws UnsupportedOperationException if the tRNS chunk data can't be set
188 | * @see #hasAlphaChannel()
189 | */
190 | public void overwriteTRNS(byte r, byte g, byte b) {
191 | if(hasAlphaChannel()) {
192 | throw new UnsupportedOperationException("image has an alpha channel");
193 | }
194 | byte[] pal = this.palette;
195 | if(pal == null) {
196 | transPixel = new byte[] { 0, r, 0, g, 0, b };
197 | } else {
198 | paletteA = new byte[pal.length/3];
199 | for(int i=0,j=0 ; i> 1)] & 255;
519 | switch(n-i) {
520 | default: dst[i+1] = (byte)(val & 15);
521 | case 1: dst[i ] = (byte)(val >> 4);
522 | }
523 | }
524 | }
525 |
526 | private void expand2(byte[] src, byte[] dst) {
527 | for(int i=1,n=dst.length ; i> 2)] & 255;
529 | switch(n-i) {
530 | default: dst[i+3] = (byte)((val ) & 3);
531 | case 3: dst[i+2] = (byte)((val >> 2) & 3);
532 | case 2: dst[i+1] = (byte)((val >> 4) & 3);
533 | case 1: dst[i ] = (byte)((val >> 6) );
534 | }
535 | }
536 | }
537 |
538 | private void expand1(byte[] src, byte[] dst) {
539 | for(int i=1,n=dst.length ; i> 3)] & 255;
541 | switch(n-i) {
542 | default: dst[i+7] = (byte)((val ) & 1);
543 | case 7: dst[i+6] = (byte)((val >> 1) & 1);
544 | case 6: dst[i+5] = (byte)((val >> 2) & 1);
545 | case 5: dst[i+4] = (byte)((val >> 3) & 1);
546 | case 4: dst[i+3] = (byte)((val >> 4) & 1);
547 | case 3: dst[i+2] = (byte)((val >> 5) & 1);
548 | case 2: dst[i+1] = (byte)((val >> 6) & 1);
549 | case 1: dst[i ] = (byte)((val >> 7) );
550 | }
551 | }
552 | }
553 |
554 | private void unfilter(byte[] curLine, byte[] prevLine) throws IOException {
555 | switch (curLine[0]) {
556 | case 0: // none
557 | break;
558 | case 1:
559 | unfilterSub(curLine);
560 | break;
561 | case 2:
562 | unfilterUp(curLine, prevLine);
563 | break;
564 | case 3:
565 | unfilterAverage(curLine, prevLine);
566 | break;
567 | case 4:
568 | unfilterPaeth(curLine, prevLine);
569 | break;
570 | default:
571 | throw new IOException("invalide filter type in scanline: " + curLine[0]);
572 | }
573 | }
574 |
575 | private void unfilterSub(byte[] curLine) {
576 | final int bpp = this.bytesPerPixel;
577 | for(int i=bpp+1,n=curLine.length ; i>> 1);
595 | }
596 | for(int n=curLine.length ; i>> 1);
598 | }
599 | }
600 |
601 | private void unfilterPaeth(byte[] curLine, byte[] prevLine) {
602 | final int bpp = this.bytesPerPixel;
603 |
604 | int i;
605 | for(i=1 ; i<=bpp ; ++i) {
606 | curLine[i] += prevLine[i];
607 | }
608 | for(int n=curLine.length ; i 256 || (chunkLength % 3) != 0) {
687 | throw new IOException("PLTE chunk has wrong length");
688 | }
689 | palette = new byte[paletteEntries*3];
690 | readChunk(palette, 0, palette.length);
691 | }
692 |
693 | private void readtRNS() throws IOException {
694 | switch (colorType) {
695 | case COLOR_GREYSCALE:
696 | checkChunkLength(2);
697 | transPixel = new byte[2];
698 | readChunk(transPixel, 0, 2);
699 | break;
700 | case COLOR_TRUECOLOR:
701 | checkChunkLength(6);
702 | transPixel = new byte[6];
703 | readChunk(transPixel, 0, 6);
704 | break;
705 | case COLOR_INDEXED:
706 | if(palette == null) {
707 | throw new IOException("tRNS chunk without PLTE chunk");
708 | }
709 | paletteA = new byte[palette.length/3];
710 | Arrays.fill(paletteA, (byte)0xFF);
711 | readChunk(paletteA, 0, paletteA.length);
712 | break;
713 | default:
714 | // just ignore it
715 | }
716 | }
717 |
718 | private void closeChunk() throws IOException {
719 | if(chunkRemaining > 0) {
720 | // just skip the rest and the CRC
721 | skip(chunkRemaining + 4);
722 | } else {
723 | readFully(buffer, 0, 4);
724 | int expectedCrc = readInt(buffer, 0);
725 | int computedCrc = (int)crc.getValue();
726 | if(computedCrc != expectedCrc) {
727 | throw new IOException("Invalid CRC");
728 | }
729 | }
730 | chunkRemaining = 0;
731 | chunkLength = 0;
732 | chunkType = 0;
733 | }
734 |
735 | private void openChunk() throws IOException {
736 | readFully(buffer, 0, 8);
737 | chunkLength = readInt(buffer, 0);
738 | chunkType = readInt(buffer, 4);
739 | chunkRemaining = chunkLength;
740 | crc.reset();
741 | crc.update(buffer, 4, 4); // only chunkType
742 | }
743 |
744 | private void openChunk(int expected) throws IOException {
745 | openChunk();
746 | if(chunkType != expected) {
747 | throw new IOException("Expected chunk: " + Integer.toHexString(expected));
748 | }
749 | }
750 |
751 | private void checkChunkLength(int expected) throws IOException {
752 | if(chunkLength != expected) {
753 | throw new IOException("Chunk has wrong size");
754 | }
755 | }
756 |
757 | private int readChunk(byte[] buffer, int offset, int length) throws IOException {
758 | if(length > chunkRemaining) {
759 | length = chunkRemaining;
760 | }
761 | readFully(buffer, offset, length);
762 | crc.update(buffer, offset, length);
763 | chunkRemaining -= length;
764 | return length;
765 | }
766 |
767 | private void refillInflater(Inflater inflater) throws IOException {
768 | while(chunkRemaining == 0) {
769 | closeChunk();
770 | openChunk(IDAT);
771 | }
772 | int read = readChunk(buffer, 0, buffer.length);
773 | inflater.setInput(buffer, 0, read);
774 | }
775 |
776 | private void readChunkUnzip(Inflater inflater, byte[] buffer, int offset, int length) throws IOException {
777 | assert(buffer != this.buffer);
778 | try {
779 | do {
780 | int read = inflater.inflate(buffer, offset, length);
781 | if(read <= 0) {
782 | if(inflater.finished()) {
783 | throw new EOFException();
784 | }
785 | if(inflater.needsInput()) {
786 | refillInflater(inflater);
787 | } else {
788 | throw new IOException("Can't inflate " + length + " bytes");
789 | }
790 | } else {
791 | offset += read;
792 | length -= read;
793 | }
794 | } while(length > 0);
795 | } catch (DataFormatException ex) {
796 | throw (IOException)(new IOException("inflate error").initCause(ex));
797 | }
798 | }
799 |
800 | private void readFully(byte[] buffer, int offset, int length) throws IOException {
801 | do {
802 | int read = input.read(buffer, offset, length);
803 | if(read < 0) {
804 | throw new EOFException();
805 | }
806 | offset += read;
807 | length -= read;
808 | } while(length > 0);
809 | }
810 |
811 | private int readInt(byte[] buffer, int offset) {
812 | return
813 | ((buffer[offset ] ) << 24) |
814 | ((buffer[offset+1] & 255) << 16) |
815 | ((buffer[offset+2] & 255) << 8) |
816 | ((buffer[offset+3] & 255) );
817 | }
818 |
819 | private void skip(long amount) throws IOException {
820 | while(amount > 0) {
821 | long skipped = input.skip(amount);
822 | if(skipped < 0) {
823 | throw new EOFException();
824 | }
825 | amount -= skipped;
826 | }
827 | }
828 |
829 | private static boolean checkSignature(byte[] buffer) {
830 | for(int i=0 ; i gameItems;
39 | public World world;
40 |
41 | public CubeStruct() {
42 | camera.position.add(0, 1.5f+20f, 0);
43 | camera.rotation.add(-80f,0.0f, 0);
44 | renderer = new Renderer();
45 | }
46 |
47 | @Override
48 | public void init(Window window) throws Exception {
49 | this.window=window;
50 | window.gl=this;
51 | renderer.init(window);
52 |
53 | gameItems = new ArrayList();
54 | world=new World(new BasicGen(1));
55 | System.out.println("WORLD GEND");
56 |
57 | if(world==null){
58 | for(float y=-5.0f;y<=0.0f;y++){
59 | for(float x=-7.0f;x<=8.0f;x++){
60 | for(float z=-7.0f;z<=8.0f;z++){
61 | GameItem gameItem = new Cube(new Vector3f(1.0f,1.0f,1.0f),y<0.0?"/textures/dirt.png":"/textures/grass.png");
62 | gameItem.setPosition(x, y, z);
63 |
64 | gameItems.add(gameItem);
65 | }
66 | }
67 | }
68 | }else{
69 | GameItem gameItem = new Cube(new Vector3f(1.0f,1.0f,1.0f),"/textures/dirt.png");
70 | gameItem.setPosition(0,5,0);
71 |
72 | gameItems.add(gameItem);
73 | }
74 |
75 | glfwSetInputMode(window.windowHandle, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
76 |
77 | }
78 |
79 | @Override
80 | public void input() {
81 | displyInc = 0;
82 | displxInc = 0;
83 | displzInc = 0;
84 | scaleInc = 0;
85 | ByteBuffer xpos = ByteBuffer.allocate(8);
86 | ByteBuffer ypos = ByteBuffer.allocate(8);
87 | DoubleBuffer x = BufferUtils.createDoubleBuffer(1);
88 | DoubleBuffer y = BufferUtils.createDoubleBuffer(1);
89 |
90 | glfwGetCursorPos(window.windowHandle, x, y);
91 |
92 | x.rewind();
93 | y.rewind();
94 |
95 | double newX = x.get();
96 | double newY = y.get();
97 | //System.out.println(newY);
98 |
99 | camera.rotation.x=(float) Math.max(Math.min(camera.rotation.x-(newY-window.getHeight()/2.0f)/4.0f,90.0f),-90.0f);
100 | camera.rotation.y=(float) (camera.rotation.y-(newX-window.getWidth()/2.0f)/4.0f);
101 | /* if (window.isKeyPressed(GLFW_KEY_UP)) {
102 | camera.rotation.x=Math.min(camera.rotation.x+0.1f,90.0f);
103 | }
104 | if (window.isKeyPressed(GLFW_KEY_DOWN)) {
105 | camera.rotation.x=Math.max(camera.rotation.x-0.1f,-90.0f);
106 | }
107 | if (window.isKeyPressed(GLFW_KEY_LEFT)) {
108 | camera.rotation.y=camera.rotation.y+0.1f;
109 | }
110 | if (window.isKeyPressed(GLFW_KEY_RIGHT)) {
111 | camera.rotation.y=camera.rotation.y-0.1f;
112 | }*/
113 | GLFW.glfwSetCursorPos(window.windowHandle, window.getWidth()/2.0,window.getHeight()/2.0);
114 | }
115 |
116 | @Override
117 | public void update(float interval) {
118 | if(window.isKeyPressed(GLFW_KEY_W)){
119 | camera.position=camera.getPosition().add(new Vector3f(0f,0,-interval*3.0f).rotate(
120 | new Quaternionf().setEulerAnglesXYZ(0.0f,
121 | -(float) Math.toRadians(camera.getRotation().y),0.0f)));
122 | }
123 | if(window.isKeyPressed(GLFW_KEY_S)){
124 | camera.position=camera.getPosition().add(new Vector3f(0f,0,interval*3.0f).rotate(
125 | new Quaternionf().setEulerAnglesXYZ(0.0f,
126 | -(float) Math.toRadians(camera.getRotation().y),0.0f)));
127 | }
128 | if(window.isKeyPressed(GLFW_KEY_A)){
129 | camera.position=camera.getPosition().add(new Vector3f(interval*3.0f,0,0f).rotate(
130 | new Quaternionf().setEulerAnglesXYZ(0.0f,
131 | -(float) Math.toRadians(camera.getRotation().y),0.0f)));
132 | }
133 | if(window.isKeyPressed(GLFW_KEY_D)){
134 | camera.position=camera.getPosition().add(new Vector3f(-interval*3.0f,0,0f).rotate(
135 | new Quaternionf().setEulerAnglesXYZ(0.0f,
136 | -(float) Math.toRadians(camera.getRotation().y),0.0f)));
137 | }
138 | if(window.isKeyPressed(GLFW_KEY_SPACE)){
139 | camera.position=camera.getPosition().add(new Vector3f(0.0f,interval*3.0f,0f));
140 | }
141 | if(window.isKeyPressed(GLFW.GLFW_KEY_LEFT_SHIFT) || window.isKeyPressed(GLFW.GLFW_KEY_RIGHT_SHIFT)){
142 | camera.position=camera.getPosition().add(new Vector3f(0.0f,-interval*3.0f,0f));
143 | }
144 |
145 | }
146 |
147 | @Override
148 | public void render() {
149 | world.gen();
150 | renderer.render(window,gameItems,camera,world);
151 | }
152 |
153 | @Override
154 | public void cleanup() {
155 | renderer.cleanup();
156 | world.cleanup();
157 | for (GameItem gameItem : gameItems) {
158 | gameItem.getMesh().cleanUp();
159 | }
160 | }
161 |
162 | @Override
163 | public void keyPressed(int key) {
164 | //System.out.println(key);
165 |
166 | // TODO Auto-generated method stub
167 |
168 | }
169 |
170 | }
171 |
--------------------------------------------------------------------------------
/src/org/cubestruct/game/Main.java:
--------------------------------------------------------------------------------
1 | package org.cubestruct.game;
2 |
3 | import cm.cubestruct.engine.GameEngine;
4 | import cm.cubestruct.engine.IGameLogic;
5 |
6 | public class Main {
7 | public static final String GAME_VERSION = "0.1 beta #1";
8 | public static final String GAME_NAME = "CubeStruct";
9 | public static void main(String[] args) {
10 | try {
11 | boolean vSync = true;
12 | IGameLogic gameLogic = new CubeStruct();
13 | GameEngine gameEng = new GameEngine(GAME_NAME, 600, 480, vSync, gameLogic);
14 | gameEng.start();
15 | } catch (Exception excp) {
16 | excp.printStackTrace();
17 | System.exit(-1);
18 | }
19 | }
20 | }
--------------------------------------------------------------------------------
/src/org/cubestruct/game/Renderer.java:
--------------------------------------------------------------------------------
1 | package org.cubestruct.game;
2 |
3 | import org.joml.Matrix4f;
4 | import org.lwjgl.opengl.GL11;
5 |
6 | import cm.cubestruct.engine.GameItem;
7 | import cm.cubestruct.engine.Utils;
8 | import cm.cubestruct.engine.Window;
9 | import cm.cubestruct.engine.render.Camera;
10 | import cm.cubestruct.engine.render.ShaderProgram;
11 | import cm.cubestruct.engine.render.Transformation;
12 | import cm.cubestruct.world.World;
13 |
14 | import static org.lwjgl.opengl.GL11.*;
15 |
16 | import java.nio.FloatBuffer;
17 | import java.util.ArrayList;
18 |
19 | public class Renderer {
20 |
21 | /**
22 | * Field of View in Radians
23 | */
24 | private static final float FOV = (float) Math.toRadians(60.0f);
25 |
26 | private static final float Z_NEAR = 0.01f;
27 |
28 | private static final float Z_FAR = 100.f;
29 |
30 | private final Transformation transformation;
31 |
32 | private ShaderProgram shaderProgram;
33 |
34 | public Renderer() {
35 | transformation = new Transformation();
36 | }
37 |
38 | public void init(Window window) throws Exception {
39 | // Create shader
40 | shaderProgram = new ShaderProgram();
41 | shaderProgram.createVertexShader(Utils.loadResource("/shaders/vertex.vs"));
42 | shaderProgram.createFragmentShader(Utils.loadResource("/shaders/fragment.fs"));
43 | shaderProgram.link();
44 |
45 | // Create uniforms for world and projection matrices and texture
46 | shaderProgram.createUniform("projectionMatrix");
47 | shaderProgram.createUniform("worldMatrix");
48 | shaderProgram.createUniform("texture_sampler");
49 | }
50 |
51 | public void clear() {
52 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
53 | }
54 |
55 | public void render(Window window, ArrayList gameItems,Camera camera,World world) {
56 | clear();
57 | ArrayList allGameItems=new ArrayList();
58 | allGameItems.addAll(gameItems);
59 | if(world!=null){
60 | allGameItems.addAll(world.renderItems());
61 | }
62 | if ( window.isResized() ) {
63 | glViewport(0, 0, window.getWidth(), window.getHeight());
64 | window.setResized(false);
65 | }
66 |
67 | shaderProgram.bind();
68 |
69 | //GL11.glLoadMatrixf(new Matrix4f().identity().get(FloatBuffer.allocate(16)));
70 | // GL11.glTranslatef(camera.getPosition().x, camera.getPosition().y, camera.getPosition().z);
71 | // Update projection Matrix
72 | Matrix4f projectionMatrix = transformation.getProjectionMatrix(FOV, window.getWidth(), window.getHeight(), Z_NEAR, Z_FAR);
73 |
74 | shaderProgram.setUniform("projectionMatrix", projectionMatrix);
75 |
76 | shaderProgram.setUniform("texture_sampler", 0);
77 | // Render each gameItem
78 | for(GameItem gameItem : allGameItems) {
79 | // Set world matrix for this item
80 | Matrix4f worldMatrix = transformation.getWorldMatrix(
81 | gameItem.getPosition(),
82 | gameItem.getRotation(),
83 | gameItem.getScale(),camera);
84 | shaderProgram.setUniform("worldMatrix", worldMatrix);
85 |
86 | // Render the mes for this game item
87 | gameItem.render();
88 | }
89 |
90 | shaderProgram.unbind();
91 | }
92 |
93 | public void cleanup() {
94 | if (shaderProgram != null) {
95 | shaderProgram.cleanup();
96 | }
97 | }
98 | }
99 |
--------------------------------------------------------------------------------