CODEWITHSUNDEEP
opengllibgdxopengl-es-2.0
SteveL
SteveL

Reputation: 3389

OpenGL pass packed texture coordinates to the shader

I need to do some heavy optimizations in my game and I was thinking since we can pass a vec4 color to the shader packed to only one float, is there a way to pass the vec2 texture coordinates too? For example in the following code can I pass the 2 texture coords(its always 1 and 0) as only one element,in the same way as its happening in the color element.

public void point(float x,float y,float z,float size,float color){
    float hsize=size/2;
    if(index>vertices.length-7)return;
    vertices[index++]=x-hsize;
    vertices[index++]=y-hsize;
    vertices[index++]=color;
    vertices[index++]=0;
    vertices[index++]=0;

    vertices[index++]=x+hsize;
    vertices[index++]=y-hsize;
    vertices[index++]=color;
    vertices[index++]=1;
    vertices[index++]=0;

    vertices[index++]=x+hsize;
    vertices[index++]=y+hsize;
    vertices[index++]=color;
    vertices[index++]=1;
    vertices[index++]=1;

    vertices[index++]=x-hsize;
    vertices[index++]=y+hsize;
    vertices[index++]=color;
    vertices[index++]=0;
    vertices[index++]=1;

    num++;
}
{
    mesh=new Mesh(false,COUNT*20, indices.length,
            new VertexAttribute(Usage.Position, 2,"a_position"),
            new VertexAttribute(Usage.ColorPacked, 4,"a_color"),
            new VertexAttribute(Usage.TextureCoordinates, 2,"a_texCoord0")
    );
}

frag shader

varying vec4 v_color;
varying vec2 v_texCoords;
uniform sampler2D u_texture;

void main() {
    vec4 color=v_color * texture2D(u_texture, v_texCoords);
    gl_FragColor = color;
}

vert shader

attribute vec4 a_position;
attribute vec4 a_color;
attribute vec2 a_texCoord0;

uniform mat4 u_projTrans;

varying vec4 v_color;
varying vec2 v_texCoords;

void main() {
    v_color = a_color;
    v_texCoords = a_texCoord0;
    gl_Position = u_projTrans * a_position;
}

I know this will not make a big difference in the performance but I am just willing to spend some extra hours here and there to make this small optimizations in order to make my game run faster.

Upvotes: 0

Views: 900

Answers (1)

Tenfour04
Tenfour04

Reputation: 93531

I haven't tried this but I think it will work. Simply use Usage.ColorPacked for your texture coordinates. I don't think you can send anything smaller than 4 bytes, so you may as well use the already defined packed color. You will only be saving one byte per vertex. You can put your coordinates into the first two elements and ignore the second two elements.

mesh = new Mesh(false,COUNT*20, indices.length,
        new VertexAttribute(Usage.Position, 2,"a_position"),
        new VertexAttribute(Usage.ColorPacked, 4,"a_color"),
        new VertexAttribute(Usage.ColorPacked, 4,"a_texCoord0")
);

I don't think the usage parameter of VertexAttribute is actually used by anything in Libgdx. If you look at the source, it only checks if the usage is ColorPacked or not, and from that decides whether to use a single byte per component versus 4.

And in your vertex shader:

attribute vec4 a_position;
attribute vec4 a_color;
attribute vec4 a_texCoord0; //note using vec4

uniform mat4 u_projTrans;

varying vec4 v_color;
varying vec2 v_texCoords;

void main() {
    v_color = a_color;
    v_texCoords = a_texCoord0.xy; //using the first two elements
    gl_Position = u_projTrans * a_position;
}

To translate the texture coordinate correctly:

final Color texCoordColor = new Color(0, 0, 0, 0);

//....

texCoordColor.r = texCoord.x;
texCoordColor.g = texCoord.y;
float texCoord = texCoordColor.toFloatBits();

Upvotes: 1

Related Questions