Hello Guest

[Solved] gldepthtest not working

  • 1 Replies
  • 2492 Views
[Solved] gldepthtest not working
« on: September 20, 2014, 19:17:50 »
hello, I followed thinMatrix's tutorials and i got a problem when I render the cube: glDepthTest is not working look in the attached file.
I enabled depth Test and the clear buffer bit. It's easier to show the relevant code:
Code: [Select]
public class Renderer {
public static final float fov = 45;
public static final float ZNear = 0.1f;
public static final float ZFar = 10000;

private Matrix4f projectionMatrix;

public Renderer(StaticShader shader){
createProjectionMatrix();
shader.start();
shader.loadProjectionMatrix(projectionMatrix);
shader.stop();
}

public void prepare() {
GL11.glEnable(GL11.GL_DEPTH_TEST);
GL11.glEnable(GL11.GL_BLEND);
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);

GL11.glClear(GL11.GL_COLOR_BUFFER_BIT|GL11.GL_DEPTH_BUFFER_BIT);
GL11.glClearColor(0.25f, 0, 0, 1);
}

public void render(Entity entity,StaticShader shader) {
RawModel model = entity.getModel().getModel();
GL30.glBindVertexArray(model.getVaoID());
GL20.glEnableVertexAttribArray(0);
GL20.glEnableVertexAttribArray(1);
Matrix4f transformation = Maths.createTransformationMatrix(entity.getTransform());
shader.loadTransformationMatrix(transformation);

GL13.glActiveTexture(GL13.GL_TEXTURE0);
GL11.glBindTexture(GL11.GL_TEXTURE_2D, entity.getModel().getTexture().getID());
GL11.glDrawElements(GL11.GL_TRIANGLES, model.getVertexCount(), GL11.GL_UNSIGNED_INT, 0);
GL20.glDisableVertexAttribArray(0);
GL20.glDisableVertexAttribArray(1);
GL30.glBindVertexArray(0);
}

private void createProjectionMatrix(){
float aspectRatio = (float) Display.getWidth()/ (float) Display.getHeight();
float yscale = (float)((1f/Math.tan(Math.toRadians(fov /2f ))) * aspectRatio);
float xscale = yscale/aspectRatio;
float frustrumlength = ZFar - ZNear;

projectionMatrix = new Matrix4f();
projectionMatrix.m00 = xscale;
projectionMatrix.m11 = yscale;
projectionMatrix.m22 = -((ZFar + ZNear)/ frustrumlength);
projectionMatrix.m23 = -1;
projectionMatrix.m32 = -((2*ZNear*ZFar)/frustrumlength);
projectionMatrix.m33 = 0;
}

}
Code: [Select]
public class MainTest {

public MainTest() {
DisplayManager.createDisplay();
Loader loader = new Loader();

StaticShader shader = new StaticShader();
Renderer renderer = new Renderer(shader);
float[] vertices = { -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f, 0.5f, -0.5f,

-0.5f, 0.5f, 0.5f, -0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f,

0.5f, 0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f, 0.5f,

-0.5f, 0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f,

-0.5f, 0.5f, 0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f, 0.5f, 0.5f,

-0.5f, -0.5f, 0.5f, -0.5f, -0.5f, -0.5f, 0.5f, -0.5f, -0.5f, 0.5f, -0.5f, 0.5f

};

float[] textureCoords = {

0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0

};

int[] indices = { 0, 1, 3, 3, 1, 2, 4, 5, 7, 7, 5, 6, 8, 9, 11, 11, 9, 10, 12, 13, 15, 15, 13, 14, 16, 17, 19, 19, 17, 18, 20, 21, 23, 23, 21, 22

};

RawModel model = loader.loadToVAO(vertices, textureCoords, indices);
ModelTexture texture = new ModelTexture(loader.loadTexture("castle"));
TexturedModel texmodel = new TexturedModel(model, texture);
Entity entity = new Entity(texmodel, new Transform(new Vector3f(0.1f, 0.1f, -10), new Vector3f(0, 0, 0), new Vector3f(1, 1, 1)));
Camera camera = new Camera();
while (!Display.isCloseRequested()) {
// game logic
entity.rotate(1, 1, 0);
camera.move();
renderer.prepare();
shader.start();
shader.loadViewMatrix(camera);
renderer.render(entity, shader);
shader.stop();
DisplayManager.updateDisplay();
}

shader.cleanUp();
loader.cleanUp();
DisplayManager.closeDisplay();
}
}
Code: [Select]
public class Loader {

private List<Integer> vaos = new ArrayList<Integer>();
private List<Integer> vbos = new ArrayList<Integer>();
private List<Integer> textures = new ArrayList<Integer>();

public RawModel loadToVAO(float[] positions,float[] textureCoords, int[] indices) {
int vaoID = createVAO();
bindIndicesBuffer(indices);
storeDataInAttributeList(0,3, positions);
storeDataInAttributeList(1,2, textureCoords);
unbindVAO();
Logger.log("Successfully loaded index to vao", Logger.INFO);
return new RawModel(vaoID, indices.length);

}

public int loadTexture(String name) {

Texture texture = null;
try {
texture = TextureLoader.getTexture("PNG", new FileInputStream("res/" + name + ".png"));
} catch (IOException e) {
Logger.log("Failed loading texture (" + name + ")", Logger.SEVERE);
e.printStackTrace();
}
Logger.log("Sucessfully loaded texture "+name , Logger.INFO);
return texture.getTextureID();

}

public void cleanUp() {
for (int vao : vaos) {
GL30.glDeleteVertexArrays(vao);
}
for (int vbo : vbos) {
GL15.glDeleteBuffers(vbo);
}
for (int tex : textures){
GL11.glDeleteTextures(tex);
}
Logger.log("VBO,VAO,Texture cleanup successfully done",Logger.INFO);
}

private int createVAO() {
int vaoID = GL30.glGenVertexArrays();
vaos.add(vaoID);
GL30.glBindVertexArray(vaoID);
Logger.log("Successfully created VAO "+vaoID, Logger.INFO);
return vaoID;
}

private void storeDataInAttributeList(int attributeNumber,int AttribSize, float[] data) {
int vboID = GL15.glGenBuffers();
vbos.add(vboID);
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, vboID);
FloatBuffer buffer = storeDataInFloatBuffer(data);
GL15.glBufferData(GL15.GL_ARRAY_BUFFER, buffer, GL15.GL_STATIC_DRAW);
GL20.glVertexAttribPointer(attributeNumber, AttribSize, GL11.GL_FLOAT, false, 0, 0);
GL15.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
Logger.log("Successfully stored data in atribute list", Logger.INFO);
}

private void unbindVAO() {
GL30.glBindVertexArray(0);
Logger.log("Successfully unbound vao", Logger.INFO);
}

private void bindIndicesBuffer(int[] indices) {
int vboID = GL15.glGenBuffers();
vbos.add(vboID);
GL15.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, vboID);
IntBuffer buffer = storeDataInIntBuffer(indices);
GL15.glBufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, buffer, GL15.GL_STATIC_DRAW);
Logger.log("Sucessfully bound indices buffer", Logger.INFO);
}

private IntBuffer storeDataInIntBuffer(int[] data) {
IntBuffer buffer = BufferUtils.createIntBuffer(data.length);
buffer.put(data);
buffer.flip();
Logger.log("Sucessfully stored data in an int buffer", Logger.INFO);
return buffer;
}

private FloatBuffer storeDataInFloatBuffer(float[] data) {
FloatBuffer buffer = BufferUtils.createFloatBuffer(data.length);
buffer.put(data);
buffer.flip();
Logger.log("Sucessfully stored data in a float buffer", Logger.INFO);
return buffer;
}

}
Code: [Select]
public abstract class ShaderProgram {

private int programID;
private int vertexShaderID;
private int fragmentShaderID;

private static FloatBuffer matrixBuffer = BufferUtils.createFloatBuffer(16);

public ShaderProgram(String vertexFile,String fragmentFile){
vertexShaderID = loadShader(vertexFile,GL20.GL_VERTEX_SHADER);
fragmentShaderID = loadShader(fragmentFile,GL20.GL_FRAGMENT_SHADER);
programID = GL20.glCreateProgram();
GL20.glAttachShader(programID, vertexShaderID);
GL20.glAttachShader(programID, fragmentShaderID);
bindAttributes();
GL20.glLinkProgram(programID);
GL20.glValidateProgram(programID);
getAllUniformLocations();
}
protected abstract void getAllUniformLocations();

protected int getUniformLocation(String uniformName){
return GL20.glGetUniformLocation(programID, uniformName);
}

public void start(){
GL20.glUseProgram(programID);
}

public void stop(){
GL20.glUseProgram(0);
}

public void cleanUp(){
stop();
GL20.glDetachShader(programID, vertexShaderID);
GL20.glDetachShader(programID, fragmentShaderID);
GL20.glDeleteShader(vertexShaderID);
GL20.glDeleteShader(fragmentShaderID);
GL20.glDeleteProgram(programID);
}

protected abstract void bindAttributes();

protected void bindAttribute(int attribute, String variableName){
GL20.glBindAttribLocation(programID, attribute, variableName);
}

protected void loadFloat(int location, float value){
GL20.glUniform1f(location, value);
}

protected void loadVector(int location, Vector3f vector){
GL20.glUniform3f(location, vector.x, vector.y, vector.z);
}

protected void loadBool(int location,boolean value){
float toLoad = 0;
if(value){
toLoad = 1;
}
GL20.glUniform1f(location, toLoad);
}

protected void loadMatrix(int location, Matrix4f matrix){
matrix.store(matrixBuffer);
matrixBuffer.flip();
GL20.glUniformMatrix4(location, false, matrixBuffer);
}

private static int loadShader(String file, int type){
StringBuilder shaderSource = new StringBuilder();
try{
BufferedReader reader = new BufferedReader(new FileReader(file));
String line;
while((line = reader.readLine())!=null){
shaderSource.append(line).append("\n");
}
reader.close();
}catch(IOException e){
e.printStackTrace();
System.exit(-1);
}
int shaderID = GL20.glCreateShader(type);
GL20.glShaderSource(shaderID, shaderSource);
GL20.glCompileShader(shaderID);
if(GL20.glGetShaderi(shaderID, GL20.GL_COMPILE_STATUS )== GL11.GL_FALSE){
System.out.println(GL20.glGetShaderInfoLog(shaderID, 500));
System.err.println("Could not compile shader!");
System.exit(-1);
}
return shaderID;
}

}
Code: [Select]
public class Maths {

public static Matrix4f createTransformationMatrix(Transform transform){
Matrix4f matrix = new Matrix4f();

matrix.setIdentity();
Matrix4f.translate(transform.getPos(), matrix, matrix);
Matrix4f.rotate((float) Math.toRadians(transform.getRot().getX()), new Vector3f(1,0,0), matrix, matrix);
Matrix4f.rotate((float) Math.toRadians(transform.getRot().getY()), new Vector3f(0,1,0), matrix, matrix);
Matrix4f.rotate((float) Math.toRadians(transform.getRot().getZ()), new Vector3f(0,0,1), matrix, matrix);
Matrix4f.scale(transform.getScale(), matrix, matrix);

return matrix;

}

public static Matrix4f createViewMatrix(Transform transform){
Matrix4f matrix = new Matrix4f();

matrix.setIdentity();
Matrix4f.translate(new Vector3f(-transform.getPos().x,-transform.getPos().y,-transform.getPos().z), matrix, matrix);
Matrix4f.rotate((float) Math.toRadians(transform.getRot().getX()), new Vector3f(1,0,0), matrix, matrix);
Matrix4f.rotate((float) Math.toRadians(transform.getRot().getY()), new Vector3f(0,1,0), matrix, matrix);
Matrix4f.rotate((float) Math.toRadians(transform.getRot().getZ()), new Vector3f(0,0,1), matrix, matrix);

return matrix;

}

}
Code: [Select]
public class DisplayManager {

private static final int WIDTH = 1280;
private static final int HEIGHT = 720;
private static final int FPS_CAP = 120;

public static void createDisplay() {
ContextAttribs attribs = new ContextAttribs(3, 2).withForwardCompatible(true).withProfileCore(true);

try {
Display.setDisplayMode(new DisplayMode(WIDTH, HEIGHT));
Display.create(new PixelFormat(8,0,0,16), attribs);
Display.setTitle("Germinis");
} catch (LWJGLException e) {
e.printStackTrace();
}

GL11.glViewport(0, 0, WIDTH, HEIGHT);
}

public static void updateDisplay() {

Display.sync(FPS_CAP);
Display.update();

}

public static void closeDisplay() {

Display.destroy();

}

}

I hope someone can find the error soon  :)

thanks for your help.

Suggestions to look somewhere is a good help too.
« Last Edit: September 20, 2014, 20:44:51 by Wicpar »

Re: gldepthtest not working
« Reply #1 on: September 20, 2014, 20:43:54 »
nevermind, I just had to fix the display manager:
Code: [Select]
try {
Display.setDisplayMode(new DisplayMode(WIDTH, HEIGHT));
Display.create(new PixelFormat(8,8,0,8), attribs);
Display.setTitle("Germinis");
} catch (LWJGLException e) {
e.printStackTrace();
}
I forgot the 8 in the second position of PixelFormat