VertexArray with two square, how to rotate only one of them

OpenGL Development
#1

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


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;
	}
#2

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

#3

What do you mean CPU can you tell a little more?
I’m not sure do I thinking about what you thinking

#4

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.

#5

Yes I know I can do this but also I know about

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.

#6

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…

#7

If it’s not a problem then YES please explain.

#8

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.

#9

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’s_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


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();
	}

}



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.

#10

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. >_<



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:


uniform mat4x4 matrix;

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

Thanks a lot!
Example works after really small modification :wink:

http://img809.imageshack.us/img809/1756/pichp.jpg

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 ;)) … .

#12

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.

#13

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!

http://img821.imageshack.us/img821/8039/shaders2.jpg


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();
		}
	}
}



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



//screen.frag
uniform sampler2D tex;
void main(){
    gl_FragColor = texture2D(tex, gl_TexCoord[0].st);
}
#14

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