Posted by
slava_jazz on
Mar 22, 2012; 10:35am
URL: https://forum.jogamp.org/blank-screen-by-shader-render-tp3848071.html
Hi All, sorry for dummy question, but you are my last hope...

I am using:
jogl: windows-amd64 build 2.0-b45-20111219 on Windows7.
Native GL: 4.2.0 ( gl2.glGetString(GL.GL_VERSION) )
Graphic card: Nvidia Quadro 600
Currently I am trying to complete very simply program, which shows a single white triangle using shader based rendering. Unfortunately, because result screen is always blank,it looks like that I did some mistakes, which I can not see... Would anybody help me to find where and what is wrong?
Sorry for lot of code

Triangle.java::=
import com.jogamp.opengl.util.Animator;
import javax.media.opengl.*;
import javax.media.opengl.awt.GLCanvas;
import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.ShortBuffer;
import java.util.Scanner;
public class Triangle implements GLEventListener
{
private static final int INITIAL_SURFACE_WIDTH = 300;
private static final int INITIAL_SURFACE_HEIGHT = 300;
private static final float SHAPE[] =
{
-.5f, .0f, .0f,
.0f, 1.f, .0f,
.5f, .0f, .0f
};
private static final short INDICES[] = {0,3,6};
private static final float MATRIX[] =
{
1.f, 0f, 0f, 0f,
0.f, 1f, 0f, 0f,
0.f, 0f, 1f, 0f,
0.f, 0f, 0f, 1f
};
private static final FloatBuffer MATRIX_BUFFER = FloatBuffer.wrap(MATRIX);
private int[] data;
private int[] shader;
private int prog;
private int u_mvpMatrix;
private int a_vertex;
private boolean readyToDraw;
public static void main(String[] _a)
{
GLProfile glp = GLProfile.getDefault();
GLCapabilities caps = new GLCapabilities(glp);
GLCanvas canvas = new GLCanvas(caps);
Frame frame = new Frame("Triangle");
frame.setSize(INITIAL_SURFACE_WIDTH, INITIAL_SURFACE_HEIGHT);
frame.add(canvas);
frame.setVisible(true);
frame.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
});
canvas.addGLEventListener(new Triangle());
Animator animator = new Animator(canvas);
animator.add(canvas);
animator.start();
}
@Override
public void init(final GLAutoDrawable _gl_drawable)
{
readyToDraw = false;
try
{
GL2 gl2 = _gl_drawable.getGL().getGL2();
data = Triangle.uploadData(gl2,Triangle.SHAPE,Triangle.INDICES);
if(data != null)
{
shader = new int[]
{
Triangle.loadShaderFromFile(gl2, GL2.GL_VERTEX_SHADER, "triangle-vertex.glsl"),
Triangle.loadShaderFromFile(gl2, GL2.GL_FRAGMENT_SHADER, "triangle-fragment.glsl")
};
if(
shader[0] != -1 &&
shader[1] != -1 &&
(prog = Triangle.linkProgram(gl2,shader)) != -1 &&
(u_mvpMatrix = gl2.glGetUniformLocation(prog, "u_mvpMatrix")) >= 0 &&
(a_vertex = gl2.glGetAttribLocation(prog, "a_vertex")) >= 0
)
{
readyToDraw = true;
}
}
}
catch (Throwable e)
{
e.printStackTrace();
}
finally
{
if(!readyToDraw)
{
System.exit(-1);
}
else
{
System.out.println("ok.");
}
}
}
@Override
public void dispose(final GLAutoDrawable _gl_drawable)
{
}
@Override
public void display(final GLAutoDrawable _gl_drawable)
{
GL2 gl2 = _gl_drawable.getGL().getGL2();
// Clears the color and depth render buffer.
gl2.glClearColor(.5f, .5f, .5f, 1.f);
gl2.glClear(GL2.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
gl2.glUseProgram(prog);
// Sets the uniform to MVP Matrix.
Triangle.MATRIX_BUFFER.rewind();
gl2.glUniformMatrix4fv(u_mvpMatrix, 1, false, Triangle.MATRIX_BUFFER);
// Bind the Buffer Objects which we'll use now.
gl2.glBindBuffer(GL2.GL_ARRAY_BUFFER, data[0]);
gl2.glBindBuffer(GL2.GL_ELEMENT_ARRAY_BUFFER, data[1]);
gl2.glVertexAttribPointer(a_vertex,3 , GL2.GL_FLOAT, false, 0, 0L);
// Draws the triangles, starting by the index 0 in the IBO.
int count = Triangle.INDICES.length; // also tried with Triangle.INDICES.length/3
gl2.glDrawElements(GL2.GL_TRIANGLES, count, GL2.GL_UNSIGNED_SHORT, 0);
// Unbid all the Buffer Objects currently in use.
gl2.glBindBuffer(GL2.GL_ARRAY_BUFFER, 0);
gl2.glBindBuffer(GL2.GL_ELEMENT_ARRAY_BUFFER, 0);
gl2.glFlush();
}
@Override
public void reshape(final GLAutoDrawable _gl_drawable, final int i, final int i1, final int i2, final int i3)
{
}
private static int linkProgram(final GL2 _gl2, final int[] _shader)
{
int prog = _gl2.glCreateProgram();
_gl2.glAttachShader(prog, _shader[0]);
_gl2.glAttachShader(prog, _shader[1]);
_gl2.glLinkProgram(prog);
_gl2.glValidateProgram(prog);
IntBuffer int_buffer = IntBuffer.allocate(1);
_gl2.glGetProgramiv(prog, GL2.GL_LINK_STATUS, int_buffer);
if (int_buffer.get(0) != 1)
{
prog = -1;
int_buffer.rewind();
_gl2.glGetProgramiv(prog, GL2.GL_INFO_LOG_LENGTH, int_buffer);
int size = int_buffer.get(0);
ByteBuffer byte_buffer = ByteBuffer.allocate(size);
_gl2.glGetProgramInfoLog(prog, size, int_buffer, byte_buffer);
System.err.println("program link error:\n" + new String(byte_buffer.array(), 0, int_buffer.get(0)));
}
return prog;
}
private static int[] uploadData(final GL2 _gl2, final float[] _vertexes, final short[] _indices)
{
int h[] = new int[] {-1,-1};
_gl2.glGenBuffers(2, h, 0);
if(h[0] != -1 && h[1] != -1)
{
_gl2.glBindBuffer(GL.GL_ARRAY_BUFFER, h[0]);
_gl2.glBufferData(GL.GL_ARRAY_BUFFER, _vertexes.length, FloatBuffer.wrap(_vertexes), GL.GL_STATIC_DRAW);
_gl2.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, h[1]);
_gl2.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, _indices.length, ShortBuffer.wrap(_indices), GL.GL_STATIC_DRAW);
}
else
{
h = null;
}
return h;
}
private static int loadShaderFromFile(final GL2 _gl2, int _shader_type, final String _file_name)
{
int shader_index = -1;
String shader_source = getFileContent(_file_name);
if (shader_source != null)
{
shader_index = _gl2.glCreateShader(_shader_type);
IntBuffer int_buffer = IntBuffer.wrap(new int[]{shader_source.length()});
_gl2.glShaderSource(shader_index, 1, new String[]{shader_source}, int_buffer);
_gl2.glCompileShader(shader_index);
int_buffer.array()[0] = 0;
int_buffer.rewind();
_gl2.glGetShaderiv(shader_index, GL2.GL_INFO_LOG_LENGTH, int_buffer);
if (int_buffer.array()[0] != 1)
{
ByteBuffer byte_buffer = ByteBuffer.allocate(int_buffer.get(0));
_gl2.glGetShaderInfoLog(shader_index, int_buffer.get(0), int_buffer, byte_buffer);
System.err.println("shader compilation error:\n" + new String(byte_buffer.array(), 0, int_buffer.get(0)));
}
}
return shader_index;
}
private static String getFileContent(String _file_name)
{
String content = null;
try
{
InputStream in = new FileInputStream(_file_name);
StringBuilder buffer = new StringBuilder();
Scanner scanner = new Scanner(in);
try
{
while (scanner.hasNextLine())
{
buffer.append(scanner.nextLine() + "\n");
}
content = buffer.toString();
}
finally
{
scanner.close();
}
}
catch (FileNotFoundException e)
{
e.printStackTrace();
}
return content;
}
}
triangle-vertex.glsl::=
uniform mat4 u_mvpMatrix;
attribute vec4 a_vertex;
void main()
{
gl_Position = u_mvpMatrix * a_vertex;
}
triangle-fragment.glsl::=
void main()
{
gl_FragColor = vec4 (1.0, 1.0, 1.0, 1.0);
}