Java-Gaming.org    
Featured games (79)
games approved by the League of Dukes
Games in Showcase (477)
Games in Android Showcase (109)
games submitted by our members
Games in WIP (536)
games currently in development
News: Read the Java Gaming Resources, or peek at the official Java tutorials
 
    Home     Help   Search   Login   Register   
Pages: [1]
  ignore  |  Print  
  VertexArray with two square, how to rotate only one of them  (Read 2611 times)
0 Members and 1 Guest are viewing this topic.
Offline ernest210

Senior Newbie





« Posted 2012-02-17 09:44:30 »

Hello.
I sure it's impossible but I prefer to ask.
I'm holding position two square in one FloatBuffer. Changing position only one of them is no problem but
if is there a way to rotate only one of them (and stel holding them in same FloatBuffer)?
In code below all square rotating
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
float rquad;
   FloatBuffer vertexData;
   FloatBuffer colorData;
   public void gameLoop(){
      final int amountOfVertices = 64;
        final int vertexSize = 3;
        final int colorSize = 3;
     
        vertexData = BufferUtils.createFloatBuffer(amountOfVertices * vertexSize);
        vertexData.put(new float[]{
            -0.5f,  0.5f,  0.0f,  0.5f,  0.5f,  0.0f,  0.5f, -0.5f,  0.0f, -0.5f, -0.5f,  0.0f,
             1.0f,  0.5f,  0.0f,  2.0f,  0.5f,  0.0f,  2.0f, -0.5f,  0.0f,  1.0f, -0.5f,  0.0f
             });
        vertexData.flip();

        colorData = BufferUtils.createFloatBuffer(amountOfVertices * colorSize);
        colorData.put(new float[]{
               1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
              1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f});
        colorData.flip();
       
      while(running) {
         update();
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
         glLoadIdentity();//Matrix reseting.
        GL11.glTranslatef(0.0f, 0.0f, -6.0f); // Move Right And Into The Screen
        GL11.glRotatef(rquad, 0.5f, 0.5f, -0.5f); // Rotate The Cube On X, Y & Z
       
         glEnableClientState(GL_VERTEX_ARRAY);
            glEnableClientState(GL_COLOR_ARRAY);
         
            glVertexPointer(vertexSize, 0, vertexData);
            glColorPointer(colorSize, 0, colorData);
           
            glDrawArrays(GL_QUADS, 0, amountOfVertices);
           
            glDisableClientState(GL_COLOR_ARRAY);
            glDisableClientState(GL_VERTEX_ARRAY);
         
         Display.sync(60);
         Display.update();
      }
     
      Display.destroy();
   }
   
   private void update(){
      rquad-=0.05f;
   }
Offline theagentd
« Reply #1 - Posted 2012-02-17 10:10:56 »

Not really. The easiest way is to do the rotation on the CPU...

Myomyomyo.
Offline ernest210

Senior Newbie





« Reply #2 - Posted 2012-02-17 10:57:44 »

Not really. The easiest way is to do the rotation on the CPU...
What do you mean CPU can you tell a little more?
I'm not sure do I thinking about what you thinking
Games published by our own members! Check 'em out!
Legends of Yore - The Casual Retro Roguelike
Offline theagentd
« Reply #3 - Posted 2012-02-17 11:07:08 »

Not really. The easiest way is to do the rotation on the CPU...
What do you mean CPU can you tell a little more?
I'm not sure do I thinking about what you thinking
Sorry, I just quickly blurted that out because I thought you were working with 2D...

VBOs are meant to be used for vertices that will be processed by the same matrix, have the same texture, e.t.c. There is no way to specify which vertices will be processed how unless you do multiple draw calls on the VBO or use a vertex shader. For example you could setup the transformation matrix for the first cube, call glDrawArrays on the vertices of the first cube, setup the transformation matrix again for the second cube, call glDrawArrays, repeat. This is however pretty CPU intensive, and should be avoided if you have more than, say, 10 000 cubes.

Myomyomyo.
Offline ernest210

Senior Newbie





« Reply #4 - Posted 2012-02-17 14:02:57 »

For example you could setup the transformation matrix for the first cube, call glDrawArrays on the vertices of the first cube, setup the transformation matrix again for the second cube, call glDrawArrays, repeat. This is however pretty CPU intensive, and should be avoided if you have more than, say, 10 000 cubes.
Yes I know I can do this but also I know about
This is however pretty CPU intensive, and should be avoided if you have more than, say, 10 000 cubes.
that's why I asked.
I will try to do something in vbo, vertex shader right now it's a higher school for me.
Thanks.
Offline theagentd
« Reply #5 - Posted 2012-02-17 14:48:15 »

It is actually possible to do this without vertex shaders, but it requires OpenGL 3 support and that you do the matrix math yourself (through the LWJGL math library or any other math library of course). I can explain it if you want. EDIT: Scratch that, it does require a simple vertex shader...

Myomyomyo.
Offline ernest210

Senior Newbie





« Reply #6 - Posted 2012-02-17 15:02:26 »

I can explain it if you want. EDIT: Scratch that, it does require a simple vertex shader...
If it's not a problem then YES please explain.
Offline theagentd
« Reply #7 - Posted 2012-02-17 21:12:16 »

Okay, but first please tell me how much experience you have with
 - OpenGL in general
 - shaders
 - the LWJGL matrix/vector math library
so I don't ramble about things you already know. xd

The technique I'm talking about is called instancing, and like I said is limited to OpenGL 3 (= DirectX 10) hardware, meaning that it won't run on most Intel cards for example.

Most games need to draw multiple copies (= instances) of the same geometry but with some varying attributes, for example transformation (scale, position, rotation), animation frame, texture, e.t.c. The per-vertex data is the same for all instances, but a few per-instance variables need to be changed between each instance so we have to do a separate draw call for each instance. This is very costly for the CPU; we have expensive native OpenGL calls, and the driver also needs to process the OpenGL commands. If you're drawing 10 cubes, then this extra CPU cost is irrelevant, but if you're drawing 10 000 small cubes then these calls will most likely be the bottleneck of your program, not your GPU, since your CPU simply can't keep up with your GPU. Note that GPUs can handle millions of triangles and vertices at 60 frames per second.

Instancing is the solution to this problem. Instancing does not magically increase GPU performance, it just allows you to draw multiple instances of the same geometry at a VERY low CPU cost. Using instancing you can specify 2 VBOs, one which contain the data that is identical to all your cubes (vertex positions, colors, texture coordinates, e.t.c), and one which contain the per instance data, which in your case would be a transformation matrix for that specific instance. You then make a single draw call (glDrawElementsInstanced) and specify how many cubes you want. The "problem" is that you need a shader, since you need a custom transformation matrix attribute and therefore can't use the built in OpenGL matrix functions, which means we need to use a separate math library.

This is pretty much severe overkill for 99% of all games. If you are drawing LOTS of small 3D meshes it helps a lot, but it's purely a CPU optimization. For example, I used instancing in a skeleton animation test I made.

Myomyomyo.
Offline ernest210

Senior Newbie





« Reply #8 - Posted 2012-02-19 21:11:26 »

OK.
I spent several hours in this weekend trying to learn something about shader and unfortunately I steal don't know how to do this.
I was based on
http://lwjgl.org/wiki/index.php?title=Using_Shaders_to_Calculate_Model%27s_Position
http://lwjgl.org/wiki/index.php?title=GLSL_Shaders_with_LWJGL
and some others tutorials, something work something don't but still don't know how to rotate this square(cubs) separately using shader.
So if it isn't to much please tell me how to do this.
The problem is that the two cubes are rotated in the same direction
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
74  
75  
76  
77  
78  
79  
80  
81  
82  
83  
84  
85  
86  
package com.frame.shaders_calc;

import static org.lwjgl.opengl.GL11.GL_COLOR_ARRAY;
import static org.lwjgl.opengl.GL11.GL_QUADS;
import static org.lwjgl.opengl.GL11.GL_VERTEX_ARRAY;
import static org.lwjgl.opengl.GL11.glDisableClientState;
import static org.lwjgl.opengl.GL11.glDrawArrays;
import static org.lwjgl.opengl.GL11.glEnableClientState;
import static org.lwjgl.opengl.GL11.glVertexPointer;

import java.nio.FloatBuffer;

import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.ARBShaderObjects;
import org.lwjgl.opengl.GL11;

import com.Tool;

public class Box {
   // the shader program is held in the Shader class
  private Shader shaderAccess;

   final int allVertices = 24;
    final int vSize = 3;
    final int colorSize = 3;
   
    private FloatBuffer vData;
   
    private FloatBuffer rotate;
    private FloatBuffer position;
   
   public Box() {
      shaderAccess = new Shader();
     
      vData = BufferUtils.createFloatBuffer((allVertices * 2) * vSize);
                                    //  x    y     z     move                //x     y     z    move
       vData.put(Tool.margeCubs(Tool.getCube(0.5f, 0.5f, 0.5f, -1.5f), Tool.getCube(0.5f, 0.5f, 0.5f, 1.0f)));
        vData.flip();

        rotate = BufferUtils.createFloatBuffer(6);
        rotate.put(new float[]{45.0f, 180.0f, -9.0f, 0.0f, 0.0f,0.0f});// <--- ONLY THE FIRST THREE ARE TAKEN
       rotate.flip();
       
        position = BufferUtils.createFloatBuffer(3);
        position.put(new float[]{0.0f, 0.4f, -5.0f});
        position.flip();
   }

   public void draw() {
      GL11.glLoadIdentity();
      GL11.glPushMatrix();

      // if the shader is ok we use it
     if (shaderAccess.useShader()) {
         ARBShaderObjects.glUseProgramObjectARB(shaderAccess.getShader());
      }
      int pos = ARBShaderObjects.glGetUniformLocationARB(shaderAccess.getShader(), "pos");
      if (pos > 0) {
         ARBShaderObjects.glUniform3ARB(pos, position);
      } else {
         ARBShaderObjects.glUseProgramObjectARB(0);
      }
     
      int rot = ARBShaderObjects.glGetUniformLocationARB(
            shaderAccess.getShader(),"rot");

      if (rot > 0) {
         ARBShaderObjects.glUniform3ARB(rot, rotate);
      } else {
         ARBShaderObjects.glUseProgramObjectARB(1);
      }
      glEnableClientState(GL_VERTEX_ARRAY);
        glEnableClientState(GL_COLOR_ARRAY);
     
        glVertexPointer(vSize, 0, vData);
       
        glDrawArrays(GL_QUADS, 0, allVertices*2);
       
        glDisableClientState(GL_COLOR_ARRAY);
        glDisableClientState(GL_VERTEX_ARRAY);

      ARBShaderObjects.glUseProgramObjectARB(0);
      GL11.glPopMatrix();
   }

}

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
uniform vec3 pos;
uniform vec3 rot;
varying vec4 vertColor;

void main(){
    mat4x4 position=mat4x4(1.0);
    position[3].xyz=pos.xyz;
    mat4x4 heading=mat4x4(1.0);
    heading[0][0]=cos(rot.y);
    heading[0][2]=-(sin(rot.y));
    heading[2][0]=sin(rot.y);
    heading[2][2]=cos(rot.y);
    mat4x4 pitch=mat4x4(1.0);
    pitch[1][1]=cos(rot.x);
    pitch[1][2]=sin(rot.x);
    pitch[2][1]=-(sin(rot.x));
    pitch[2][2]=cos(rot.x);
    mat4x4 roll=mat4x4(1.0);
    roll[0][0]=cos(rot.z);
    roll[0][1]=sin(rot.z);
    roll[1][0]=-(sin(rot.z));
    roll[1][1]=cos(rot.z);

    gl_Position= gl_ModelViewProjectionMatrix*position*heading*pitch*roll*gl_Vertex;
    vertColor = vec4(0.6,0.5,0.3,1.0f);
}


theagentd
I understand that Instancing resolve my problem (it looks incredible) but for me it's to soon I'm still learning lwjgl and I just want to know how to using shader.
Offline theagentd
« Reply #9 - Posted 2012-02-20 10:16:53 »

Wow, nice progress! Getting your first shader running is pretty big achievement, but again, you have to draw each individual cube with an glDrawArrays() call.

I'd recommend you only put the vertex data of a single cube in your VBO. You then draw the same data over and over again with different transformation MATRICES. Your current vertex shader does 6 sin()s and 6 cos()es PER VERTEX, so for a cube with 24 vertices, that's pretty intensive. This is why OpenGL uses matrices in the first place.

You should change your code to something like this:

HUGE WARNING: ALL THIS WAS WRITTEN WHEN POSTING. UNTESTED. I REPEAT, UNTESTED. >_<

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
public class Box {

    public Vector3f position;
    public Vector3f scale;
    public float rotX, rotY, rotZ; //Rename to heading, pitch, e.t.c. I don't know which ones are which... xD

    public Box(Vector3f position, Vector3f scale, float rotX, float rotY, float rotZ){
        this.position = position;
        this.scale = scale;
        this.rotX = rotX;
        this.rotY = rotY;
        this.rotZ = rotZ;
    }
}

public class BoxRenderer{

    private static final Vector3f ROT_X = new Vector3f(1, 0, 0);
    private static final Vector3f ROT_Y = new Vector3f(0, 1, 0);
    private static final Vector3f ROT_Z = new Vector3f(0, 0, 1);

    private static final int NUM_VERTICES = 24;
    private static final int FLOATS_PER_VERTEX = 3; //No color yet?
   
    private Shader shader;
    private int matrixLocation;

    private FloatBuffer dataBuffer;

    private Matrix4f matrix;
    private FloatBuffer matrixBuffer;

    public BoxRenderer(){
        shader = new Shader();
        matrixLocation = ARBShaderObjects.glGetUniformLocationARB(shader.getShader(), "matrix");

        dataBuffer = BufferUtils.createFloatBuffer(NUM_VERTICES * FLOATS_PER_VERTEX);

        matrix = new Matrix4f();
        matrixBuffer = BufferUtils.createFloatBuffer(16);
    }

    public void drawBoxes(ArrayList<Box> boxes){
        ARBShaderObjects.glUseProgramObjectARB(shader.getShader());
       
        glEnableClientState(GL_VERTEX_ARRAY);
        //glEnableClientState(GL_COLOR_ARRAY); //No color data?
       
        glVertexPointer(vSize, 0, vData);

        for(int i = 0; i < boxes.size(); i++){
            Box box = boxes.get(i);
           
            matrix.setIdentity();
            matrix.translate(box.position);
            matrix.scale(box.scale);
            matrix.rotate(box.rotX, ROT_X);
            matrix.rotate(box.rotY, ROT_Y);
            matrix.rotate(box.rotZ, ROT_Z);
            matrix.store(matrixBuffer);
            matrixBuffer.flip();

            ARBShaderObjects.glUniformMatrix4ARB(matrixLocation, false, matrixBuffer);

            glDrawArrays(GL_QUADS, 0, NUM_VERTICES);
        }

        glDisableClientState(GL_VERTEX_ARRAY);

        ARBShaderObjects.glUseProgramObjectARB(0);
    }
}


You'd have to change your vertex shader to this infinitely advanced one:

1  
2  
3  
4  
5  
6  
uniform mat4x4 matrix;

void main(){
    gl_Position= gl_ModelViewProjectionMatrix*matrix*gl_Vertex;
    vertColor = vec4(0.6,0.5,0.3,1.0f);
}

Myomyomyo.
Games published by our own members! Check 'em out!
Legends of Yore - The Casual Retro Roguelike
Offline ernest210

Senior Newbie





« Reply #10 - Posted 2012-02-20 20:40:47 »

Thanks a lot!
Example works after really small modification Wink


Believe it or not but I had the idea to do something similar but I didn't know how to get around to.
This loop little worried me what if I want to create forest with thousands tree how this will be working (therefore I didn't want to use loop)?
Do I need to combine some techniques VertexArray/VertexBuffer, shaders, instancing (maybe later Wink) ... .
Offline theagentd
« Reply #11 - Posted 2012-02-21 09:06:04 »

Nice! I'm getting better at writing things without an IDE thanks to JGO. xD

There's no way to get rid of the loop completely, but we currently have two OpenGL calls right now: glUniformMatrix4ARB and glDrawArrays(GL_QUADS, 0, NUM_VERTICES). This doesn't seem like much but it is pretty bad. We're uploading our matrices one by one, 64 bytes at a time. We're also telling OpenGL to render each cube with a state changes (the uniform update) in between, but this is how fast we can get it without going over to instancing.

Since you've come this far it's very easy to just go all the way now. First though you need to change your program to use VBOs. This will allow you to store your cube vertex data on the GPU permanently instead of transmitting it every frame. Okay, you only have 24 vertices, but if you had a more advanced 3D model then it would make a difference. Try to make the program store the cube vertex data in VBO in the constructor and then draw some cubes by referencing that data. You'll need to change any gl*****Pointer(...) calls to refer to the VBO instead of sending the FloatBuffer each frame. After you've figured out how VBOs work it'll be a piece of cake to implement instancing.

Myomyomyo.
Offline ernest210

Senior Newbie





« Reply #12 - Posted 2012-02-23 22:48:56 »

In truth I did it on Tuesday, sitting to the midnight and trying to load textures but it was worth.
I know how to use VBO but sometimes I worked on an older computer which supporting only OpenGL version 1.3.
10K cubes move quite smoothly.
Anyway theagentd thanks for your help!

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
74  
75  
76  
77  
78  
79  
80  
81  
82  
83  
84  
85  
86  
87  
88  
89  
90  
91  
92  
93  
94  
95  
96  
97  
98  
99  
100  
101  
102  
103  
104  
105  
106  
107  
108  
109  
110  
111  
112  
113  
114  
public class BoxRenderer {
   // the shader program is held in the Shader class
  private Shader shaderAccess;
   
   private static final Vector3f ROT_X = new Vector3f(1, 0, 0);
    private static final Vector3f ROT_Y = new Vector3f(0, 1, 0);
    private static final Vector3f ROT_Z = new Vector3f(0, 0, 1);

   private static final int NUM_VERTICES = 24;
    final int vSize = 3;
    final int vTexSize = 2;
   
    private FloatBuffer vData;
    private FloatBuffer texData;
   
    private Matrix4f matrix;
    private FloatBuffer matrixBuffer;
   
   private ArrayList<Box> boxes = new ArrayList<Box>();
   private int vertHandle;
   private int texHandle;
   
   private Texture texture;
   
   public BoxRenderer() {
      shaderAccess = new Shader();
     
      vData = BufferUtils.createFloatBuffer(NUM_VERTICES * vSize);
        vData.put(Tool.margeCubs(Tool.getCube(0.5f, 0.5f, 0.5f)));//x,y,z
       vData.flip();
       
        texData = BufferUtils.createFloatBuffer(NUM_VERTICES * vTexSize);
        texData.put(Tool.getTexture(1.0f, 1.0f));
        texData.flip();

        matrix = new Matrix4f();
        matrixBuffer = BufferUtils.createFloatBuffer(16);
       
      boxes = ToolBox.getGenerateBoxes(10000);
     
      vertHandle = glGenBuffers();
        glBindBuffer(GL_ARRAY_BUFFER, vertHandle);
        glBufferData(GL_ARRAY_BUFFER, vData, GL_STATIC_DRAW);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
       
        texHandle = glGenBuffers();
        glBindBuffer(GL_ARRAY_BUFFER, texHandle);
        glBufferData(GL_ARRAY_BUFFER, texData, GL_STATIC_DRAW);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
       
        try {
         texture = TextureLoader.getTexture("png", ResourceLoader.getResourceAsStream("res/caution.png"));
      } catch (IOException e) {
         e.printStackTrace();
      }
   }

   public void draw() {
      GL11.glLoadIdentity();
      texture.bind();

      // if the shader is ok we use it
     if (shaderAccess.useShader()) {
         ARBShaderObjects.glUseProgramObjectARB(shaderAccess.getShader());
      }
     
      int matrixLocation = ARBShaderObjects.glGetUniformLocationARB(shaderAccess.getShader(), "matrix");
      int texcoord = ARBShaderObjects.glGetUniformLocationARB(shaderAccess.getShader(), "texcoord");
       
      glEnableClientState(GL_VERTEX_ARRAY);
        //glEnableClientState(GL11.GL_COLOR_ARRAY);
       glEnableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
     
        glBindBuffer(GL_ARRAY_BUFFER, vertHandle);
        glVertexPointer(vSize, GL_FLOAT, 0, 0L);
       
        glBindBuffer(GL_ARRAY_BUFFER, texHandle);
        glTexCoordPointer(2, GL_FLOAT, 0, 0L);
       
       
        for(int i = 0; i < boxes.size(); i++){
            Box box = boxes.get(i);
           
            matrix.setIdentity();
            matrix.translate(box.position);
            matrix.scale(box.scale);
            matrix.rotate(box.rotX, ROT_X);
            matrix.rotate(box.rotY, ROT_Y);
            matrix.rotate(box.rotZ, ROT_Z);
            matrix.store(matrixBuffer);
            matrixBuffer.flip();
            if(matrixLocation > 0) {
               ARBShaderObjects.glUniformMatrix4ARB(matrixLocation, false, matrixBuffer);
            }
            if(texcoord > 0) {
               ARBShaderObjects.glUniformMatrix2ARB(matrixLocation, false, texData);
            }
            glDrawArrays(GL_QUADS, 0, NUM_VERTICES);
        }
       
        //glDisableClientState(GL_COLOR_ARRAY);
       glDisableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
        glDisableClientState(GL_VERTEX_ARRAY);

      ARBShaderObjects.glUseProgramObjectARB(0);
   }

   public void update(){
      for(int i = 0; i < boxes.size(); i++){
            Box box = boxes.get(i);
            box.update();
      }
   }
}


1  
2  
3  
4  
5  
6  
//screen.vert
uniform mat4x4 matrix;
void main(){
   gl_TexCoord[0] = gl_MultiTexCoord0;
    gl_Position= gl_ModelViewProjectionMatrix*matrix*gl_Vertex;
}

1  
2  
3  
4  
5  
//screen.frag
uniform sampler2D tex;
void main(){
    gl_FragColor = texture2D(tex, gl_TexCoord[0].st);
}
Offline theagentd
« Reply #13 - Posted 2012-02-24 04:02:34 »

Woot, epic! The world definitely needs more cubes! =D

Myomyomyo.
Pages: [1]
  ignore  |  Print  
 
 
You cannot reply to this message, because it is very, very old.

 

Add your game by posting it in the WIP section,
or publish it in Showcase.

The first screenshot will be displayed as a thumbnail.

CogWheelz (18 views)
2014-07-30 21:08:39

Riven (26 views)
2014-07-29 18:09:19

Riven (15 views)
2014-07-29 18:08:52

Dwinin (13 views)
2014-07-29 10:59:34

E.R. Fleming (34 views)
2014-07-29 03:07:13

E.R. Fleming (12 views)
2014-07-29 03:06:25

pw (43 views)
2014-07-24 01:59:36

Riven (44 views)
2014-07-23 21:16:32

Riven (30 views)
2014-07-23 21:07:15

Riven (31 views)
2014-07-23 20:56:16
List of Learning Resources
by SilverTiger
2014-07-31 18:29:50

List of Learning Resources
by SilverTiger
2014-07-31 18:26:06

List of Learning Resources
by SilverTiger
2014-07-31 13:54:12

HotSpot Options
by dleskov
2014-07-08 03:59:08

Java and Game Development Tutorials
by SwordsMiner
2014-06-14 00:58:24

Java and Game Development Tutorials
by SwordsMiner
2014-06-14 00:47:22

How do I start Java Game Development?
by ra4king
2014-05-17 11:13:37

HotSpot Options
by Roquen
2014-05-15 09:59:54
java-gaming.org is not responsible for the content posted by its members, including references to external websites, and other references that may or may not have a relation with our primarily gaming and game production oriented community. inquiries and complaints can be sent via email to the info‑account of the company managing the website of java‑gaming.org
Powered by MySQL Powered by PHP Powered by SMF 1.1.18 | SMF © 2013, Simple Machines | Managed by Enhanced Four Valid XHTML 1.0! Valid CSS!