[Solved]libdgx - Mesh -> Matrix math curious result

OpenGL Development
#1

Hi, after I am now able to create fragshaders, they don’t even look that bad, thx for help :slight_smile:

But now I have been wondering about the vertexshader for about 13 hours ::slight_smile:
I just don’t get why vec4(aVertex,0,1)* uModelMatrix != vec4(aVertex,0,1)
In my opinion uModelMatrix is an identity matrix so it should work.
I expected a red field, the mesh coords are set weird because I just would like to see a red pixel.

What I get:
Nothing, absolutely nothing is rendered :-\

There’s the code, you could compile and test it yourself if you want :slight_smile:


import com.badlogic.gdx.ApplicationListener;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.backends.lwjgl.LwjglApplication;
import com.badlogic.gdx.backends.lwjgl.LwjglApplicationConfiguration;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL10;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.Mesh;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.VertexAttribute;
import com.badlogic.gdx.graphics.VertexAttributes.Usage;
import com.badlogic.gdx.graphics.glutils.ShaderProgram;
import com.badlogic.gdx.math.Matrix4;

public class ErrorShader implements ApplicationListener {
    MeshHelper meshHelper;

    public static void main(String[] args) {
		LwjglApplicationConfiguration cfg = new LwjglApplicationConfiguration();
		cfg.title = "Error";
		cfg.useGL20 = true;
		cfg.width = 500;
		cfg.height = 500;
		cfg.resizable = false;
		new LwjglApplication(new ErrorShader(), cfg);
	}
    
    
    @Override
    public void create() {
        meshHelper = new MeshHelper();
        meshHelper.createMesh(new float[] { -100.0f, -100.0f,
                230.0f, 100.0f,
                100f, 156.0f });
        }
    
    

    @Override
    public void resize(int width, int height) {
    }

    @Override
    public void render() {
        Gdx.graphics.getGL20().glClearColor(0.2f, 0.2f, 0.2f, 1);
        Gdx.graphics.getGL20().glClear(GL10.GL_COLOR_BUFFER_BIT);
        Gdx.graphics.getGL20().glEnable(GL20.GL_BLEND);
        //Gdx.gl.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);
        meshHelper.drawMesh();
    }

    @Override
    public void pause() {
    }

    @Override
    public void resume() {
    }

    @Override
    public void dispose() {
        meshHelper.dispose();
    }
}

class MeshHelper {
    private Mesh mesh;
    private ShaderProgram redShader;
    
    private OrthographicCamera cam;
    private Matrix4 modelMatrix;

    public MeshHelper() {
        createShader();
        modelMatrix = new Matrix4();
        cam = new OrthographicCamera(Gdx.graphics.getWidth(), Gdx.graphics.getHeight());
for(int i =0; i<  modelMatrix.getValues().length; i++){
        	System.out.println("values "+ i+": " +  modelMatrix.getValues()[i]);
        }
    }

    public void createMesh(float[] vertices) {
    	//modelMatrix.translate(translation)
    	//modelMatrix.rotate(rotation)
    	mesh = new Mesh(true, vertices.length, 0,
    	        new VertexAttribute(Usage.Position, 2, "aVertex"));
        mesh.setVertices(vertices);
    }

    public void drawMesh() {
        if (mesh == null)
            throw new IllegalStateException("drawMesh called before a mesh has been created.");
        
      //modelMatrix.translate(translation)
     // modelMatrix.rotate(250f,250f,0f, 0.5f);
      //  redShader.setUniformMatrix("uViewProjMatrix", cam.combined);
 //redShader.setUniformMatrix("uModelMatrix", modelMatrix); //Error call it inside glbegin/end
        redShader.begin();
redShader.setUniformMatrix("uModelMatrix", modelMatrix);
        mesh.render(redShader, GL20.GL_TRIANGLES);
        redShader.end();
    }

    private void createShader() {
    	String vertexShader = 
    	    	 "attribute vec2 aVertex;       \n"
    			+ "uniform mat4 uViewProjMatrix;       \n"
    			+ "uniform mat4 uModelMatrix;       \n"
                + "void main()                   \n"
                + "{                             \n"
               // + "  gl_Position = vec4(aVertex,0.0,1.0) * uModelMatrix* uViewProjMatrix;  \n"
                + "  gl_Position = vec4(aVertex,0,1)* uModelMatrix; \n"// * uViewProjMatrix;
                + "}                             \n";           
    	
        String fragmentREDShader = 
        		  "#ifdef GL_ES\n" //
                + "#define LOWP lowp\n" //
                + "precision mediump float;\n" //
                + "#else\n" //
                + "#define LOWP \n" //
                + "#endif\n" + //
                "\n" + 
                "void main() {\n" + 
                "   gl_FragColor = vec4(1.0,0.0,0.0, 1.0);\n" +
                "}";
        redShader = new ShaderProgram(vertexShader, fragmentREDShader);
        if (redShader.isCompiled() == false)
            throw new IllegalStateException(redShader.getLog());
    }
    public void dispose() {
        mesh.dispose();
        redShader.dispose();
    }
}

thx for help,
best regards

#2

You should multiply those other way around.

This is right way:


vec4 a = matrix * vector;
#3 
gl_Position = uModelMatrix*vec4(aVertex,0,1);

don’t work either, it would be strange because the order souldn’t have any effect on it.

#4

In matrix math, the order does effect the outcome.

Look through these.

#5

thx, but one of these is an identity matrix so it shouldn’t have any effect.

#6

Got the mistake, thx to bach in the libgdx irc.
I will edit my post, as soon as I wake up.
best regards and good night ;D