Java Code Examples for com.jogamp.opengl.GL2GL3#glGenBuffers()

public static void init(Renderer r, GL2GL3 gl) {
	int[] is = new int[1];
	gl.glGenBuffers(1, is, 0);
	_vertBuffer = is[0];

	Shader s = r.getShader(ShaderHandle.DEBUG);
	_progHandle = s.getProgramHandle();
	gl.glUseProgram(_progHandle);

	_modelViewMatVar = gl.glGetUniformLocation(_progHandle, "modelViewMat");
	_projMatVar = gl.glGetUniformLocation(_progHandle, "projMat");
	_colorVar = gl.glGetUniformLocation(_progHandle, "color");

	_cVar = gl.glGetUniformLocation(_progHandle, "C");
	_fcVar = gl.glGetUniformLocation(_progHandle, "FC");

	_posVar = gl.glGetAttribLocation(_progHandle, "position");

	_hasInitialized = true;
}
 

private static void initStaticData(Renderer r) {
	GL2GL3 gl = r.getGL();

	// Initialize the shader variables
	progHandle = r.getShader(Renderer.ShaderHandle.OVERLAY_FLAT).getProgramHandle();

	int[] is = new int[1];
	gl.glGenBuffers(1, is, 0);
	glBuff = is[0];

	hasTexVar = gl.glGetUniformLocation(progHandle, "useTex");
	sizeVar = gl.glGetUniformLocation(progHandle, "size");
	offsetVar = gl.glGetUniformLocation(progHandle, "offset");
	colorVar = gl.glGetUniformLocation(progHandle, "color");

	posVar = gl.glGetAttribLocation(progHandle, "position");
	staticInit = true;
}
 

private static void initStaticData(Renderer r) {
	GL2GL3 gl = r.getGL();

	// Initialize the shader variables
	progHandle = r.getShader(Renderer.ShaderHandle.OVERLAY_FLAT).getProgramHandle();

	int[] is = new int[1];
	gl.glGenBuffers(1, is, 0);
	lineGLBuff = is[0];

	hasTexVar = gl.glGetUniformLocation(progHandle, "useTex");
	sizeVar = gl.glGetUniformLocation(progHandle, "size");
	offsetVar = gl.glGetUniformLocation(progHandle, "offset");
	colorVar = gl.glGetUniformLocation(progHandle, "color");

	posVar = gl.glGetAttribLocation(progHandle, "position");
	staticInit = true;
}
 

public static void loadGPUAssets(Renderer r) {

		GL2GL3 gl = r.getGL();

		int[] buffs = new int[1];
		gl.glGenBuffers(1, buffs, 0);
		vertBuff = buffs[0];

		progHandle = r.getShader(Renderer.ShaderHandle.SKYBOX).getProgramHandle();

		projMatVar = gl.glGetUniformLocation(progHandle, "projMat");
		invViewMatVar = gl.glGetUniformLocation(progHandle, "invViewMat");
		texVar = gl.glGetUniformLocation(progHandle, "tex");

		FloatBuffer verts = FloatBuffer.allocate(6*3); // 2 triangles * 3 coordinates
		verts.put(-0.5f); verts.put(-0.5f); verts.put(-0.5f);
		verts.put( 0.5f); verts.put(-0.5f); verts.put(-0.5f);
		verts.put( 0.5f); verts.put( 0.5f); verts.put(-0.5f);

		verts.put(-0.5f); verts.put(-0.5f); verts.put(-0.5f);
		verts.put( 0.5f); verts.put( 0.5f); verts.put(-0.5f);
		verts.put(-0.5f); verts.put( 0.5f); verts.put(-0.5f);

		verts.flip();
		gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, vertBuff);
		gl.glBufferData(GL2GL3.GL_ARRAY_BUFFER, 6*3*4, verts, GL2GL3.GL_STATIC_DRAW);

		gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, 0);

		isLoaded = true;
	}
 

private void loadGPUSubLine(GL2GL3 gl, Renderer renderer, MeshData.SubLineData data) {

	Shader s = renderer.getShader(Renderer.ShaderHandle.DEBUG);

	assert (s.isGood());

	SubLine sub = new SubLine();
	sub._progHandle = s.getProgramHandle();

	int[] is = new int[1];
	gl.glGenBuffers(1, is, 0);
	sub._vertexBuffer = is[0];

	sub._numVerts = data.verts.size();

	sub._hull = data.hull;

	// Init vertices
	FloatBuffer fb = FloatBuffer.allocate(data.verts.size() * 3); //
	for (Vec3d v : data.verts) {
		RenderUtils.putPointXYZ(fb, v);
	}
	fb.flip();

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, sub._vertexBuffer);
	gl.glBufferData(GL2GL3.GL_ARRAY_BUFFER, sub._numVerts * 3 * 4, fb, GL2GL3.GL_STATIC_DRAW);

	// Bind the shader variables
	sub._modelViewMatVar = gl.glGetUniformLocation(sub._progHandle, "modelViewMat");
	sub._projMatVar = gl.glGetUniformLocation(sub._progHandle, "projMat");

	sub._diffuseColor = new Color4d(data.diffuseColor);
	sub._colorVar = gl.glGetUniformLocation(sub._progHandle, "color");

	sub._cVar = gl.glGetUniformLocation(sub._progHandle, "C");
	sub._fcVar = gl.glGetUniformLocation(sub._progHandle, "FC");

	_subLines.add(sub);
}
 

public BufferHandle allocateBuffer(int size, GL2GL3 gl) {
	int[] i = new int[1];
	gl.glGenBuffers(1, i, 0);
	int glBufferID = i[0];

	renderer.usingVRAM(size);

	BufferHandle h = new BufferHandle(glBufferID, size, this);
	allocatedBuffers.add(h);
	return h;

}
 

private void setupBuffer(GL2GL3 gl) {
	// Create an OpenGL buffer
	int[] buffs = new int[1];
	gl.glGenBuffers(1, buffs, 0);
	_glVertBuffer = buffs[0];

	_glBufferDirty = true;
}
 

private static void initStaticBuffers(Renderer r) {
	GL2GL3 gl = r.getGL();

	int[] buffs = new int[3];
	gl.glGenBuffers(3, buffs, 0);
	vertBuff = buffs[0];
	texCoordBuff = buffs[1];
	normalBuff = buffs[2];

	FloatBuffer verts = FloatBuffer.allocate(6*3); // 2 triangles * 3 coordinates
	verts.put(-0.5f); verts.put(-0.5f); verts.put(0.0f);
	verts.put( 0.5f); verts.put(-0.5f); verts.put(0.0f);
	verts.put( 0.5f); verts.put( 0.5f); verts.put(0.0f);

	verts.put(-0.5f); verts.put(-0.5f); verts.put(0.0f);
	verts.put( 0.5f); verts.put( 0.5f); verts.put(0.0f);
	verts.put(-0.5f); verts.put( 0.5f); verts.put(0.0f);

	verts.flip();
	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, vertBuff);
	gl.glBufferData(GL2GL3.GL_ARRAY_BUFFER, 6*3*4, verts, GL2GL3.GL_STATIC_DRAW);

	FloatBuffer texCoords = FloatBuffer.allocate(6*2); // 2 triangles * 2 coordinates

	texCoords.put(0.0f); texCoords.put(0.0f);
	texCoords.put(1.0f); texCoords.put(0.0f);
	texCoords.put(1.0f); texCoords.put(1.0f);

	texCoords.put(0.0f); texCoords.put(0.0f);
	texCoords.put(1.0f); texCoords.put(1.0f);
	texCoords.put(0.0f); texCoords.put(1.0f);

	texCoords.flip();
	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, texCoordBuff);
	gl.glBufferData(GL2GL3.GL_ARRAY_BUFFER, 6*2*4, texCoords, GL2GL3.GL_STATIC_DRAW);

	FloatBuffer normals = FloatBuffer.allocate(6*3); // 2 triangles * 3 coordinates
	for (int i = 0; i < 6; ++i) {
		normals.put(0.0f); normals.put(0.0f); normals.put(1.0f);
	}

	normals.flip();
	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, normalBuff);
	gl.glBufferData(GL2GL3.GL_ARRAY_BUFFER, 6*3*4, normals, GL2GL3.GL_STATIC_DRAW);

	// Initialize the shader variables
	progHandle = r.getMeshShader(Renderer.DIFF_TEX_FLAG).getProgramHandle();

	modelViewMatVar = gl.glGetUniformLocation(progHandle, "modelViewMat");
	projMatVar = gl.glGetUniformLocation(progHandle, "projMat");
	normalMatVar = gl.glGetUniformLocation(progHandle, "normalMat");
	bindSpaceMatVar = gl.glGetUniformLocation(progHandle, "bindSpaceMat");
	bindSpaceNorMatVar = gl.glGetUniformLocation(progHandle, "bindSpaceNorMat");
	texVar = gl.glGetUniformLocation(progHandle, "diffuseTex");

	lightDirVar = gl.glGetUniformLocation(progHandle, "lightDir");
	lightIntVar = gl.glGetUniformLocation(progHandle, "lightIntensity");
	numLightsVar = gl.glGetUniformLocation(progHandle, "numLights");

	specColorVar = gl.glGetUniformLocation(progHandle, "specColor");
	ambientColorVar = gl.glGetUniformLocation(progHandle, "ambientColor");
	shininessVar = gl.glGetUniformLocation(progHandle, "shininess");

	cVar = gl.glGetUniformLocation(progHandle, "C");
	fcVar = gl.glGetUniformLocation(progHandle, "FC");

	lightDir[0] = 0;
	lightDir[1] = 0;
	lightDir[2] = -1;

	lightInt[0] = 1;

	staticInit = true;
}
 

private static void initStaticBuffers(Renderer r) {
	GL2GL3 gl = r.getGL();

	int[] buffs = new int[2];
	gl.glGenBuffers(2, buffs, 0);
	vertBuff = buffs[0];
	texCoordBuff = buffs[1];

	FloatBuffer verts = FloatBuffer.allocate(6*3); // 2 triangles * 3 coordinates
	verts.put(0.0f); verts.put(0.0f); verts.put(0.0f);
	verts.put(1.0f); verts.put(0.0f); verts.put(0.0f);
	verts.put(1.0f); verts.put(1.0f); verts.put(0.0f);

	verts.put(0.0f); verts.put(0.0f); verts.put(0.0f);
	verts.put(1.0f); verts.put(1.0f); verts.put(0.0f);
	verts.put(0.0f); verts.put(1.0f); verts.put(0.0f);

	verts.flip();
	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, vertBuff);
	gl.glBufferData(GL2GL3.GL_ARRAY_BUFFER, 6*3*4, verts, GL2GL3.GL_STATIC_DRAW);

	FloatBuffer texCoords = FloatBuffer.allocate(6*2); // 2 triangles * 2 coordinates

	texCoords.put(0.0f); texCoords.put(0.0f);
	texCoords.put(1.0f); texCoords.put(0.0f);
	texCoords.put(1.0f); texCoords.put(1.0f);

	texCoords.put(0.0f); texCoords.put(0.0f);
	texCoords.put(1.0f); texCoords.put(1.0f);
	texCoords.put(0.0f); texCoords.put(1.0f);

	texCoords.flip();
	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, texCoordBuff);
	gl.glBufferData(GL2GL3.GL_ARRAY_BUFFER, 6*2*4, texCoords, GL2GL3.GL_STATIC_DRAW);

	// Initialize the shader variables
	progHandle = r.getShader(Renderer.ShaderHandle.OVERLAY_FLAT).getProgramHandle();

	texVar = gl.glGetUniformLocation(progHandle, "tex");
	hasTexVar = gl.glGetUniformLocation(progHandle, "useTex");
	sizeVar = gl.glGetUniformLocation(progHandle, "size");
	offsetVar = gl.glGetUniformLocation(progHandle, "offset");

	staticInit = true;
}
 

/**
 * Initialize the GL assets needed, this should be called with the shared GL context
 * @param gl
 */
public static void init(Renderer r, GL2GL3 gl) {
	int[] is = new int[3];
	gl.glGenBuffers(3, is, 0);
	_aabbVertBuffer = is[0];
	_boxVertBuffer = is[1];
	_lineVertBuffer = is[2];

	Shader s = r.getShader(ShaderHandle.DEBUG);
	_debugProgHandle = s.getProgramHandle();
	gl.glUseProgram(_debugProgHandle);

	_modelViewMatVar = gl.glGetUniformLocation(_debugProgHandle, "modelViewMat");
	_projMatVar = gl.glGetUniformLocation(_debugProgHandle, "projMat");
	_colorVar = gl.glGetUniformLocation(_debugProgHandle, "color");

	_posVar = gl.glGetAttribLocation(_debugProgHandle, "position");

	_cVar = gl.glGetAttribLocation(_debugProgHandle, "C");
	_fcVar = gl.glGetAttribLocation(_debugProgHandle, "FC");

	// Build up a buffer of vertices for lines in a box
	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, _aabbVertBuffer);

	FloatBuffer fb = FloatBuffer.allocate(3 * 2 * 12); // 12 line segments
	// Top lines
	app( 1,  1,  1, fb);
	app( 1, -1,  1, fb);

	app( 1, -1,  1, fb);
	app(-1, -1,  1, fb);

	app(-1, -1,  1, fb);
	app(-1,  1,  1, fb);

	app(-1,  1,  1, fb);
	app( 1,  1,  1, fb);

	// Bottom lines
	app( 1,  1, -1, fb);
	app( 1, -1, -1, fb);

	app( 1, -1, -1, fb);
	app(-1, -1, -1, fb);

	app(-1, -1, -1, fb);
	app(-1,  1, -1, fb);

	app(-1,  1, -1, fb);
	app( 1,  1, -1, fb);

	// Side lines
	app( 1,  1,  1, fb);
	app( 1,  1, -1, fb);

	app(-1,  1,  1, fb);
	app(-1,  1, -1, fb);

	app( 1, -1,  1, fb);
	app( 1, -1, -1, fb);

	app(-1, -1,  1, fb);
	app(-1, -1, -1, fb);

	fb.flip();

	gl.glBufferData(GL2GL3.GL_ARRAY_BUFFER, 3 * 2 * 12 * 4, fb, GL2GL3.GL_STATIC_DRAW);
	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, 0);

	// Create a buffer for drawing rectangles
	// Build up a buffer of vertices for lines in a box
	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, _boxVertBuffer);

	fb = FloatBuffer.allocate(3 * 2 * 4); // 4 line segments

	// lines
	app( 0.5f,  0.5f,  0, fb);
	app( 0.5f, -0.5f,  0, fb);

	app( 0.5f, -0.5f,  0, fb);
	app(-0.5f, -0.5f,  0, fb);

	app(-0.5f, -0.5f,  0, fb);
	app(-0.5f,  0.5f,  0, fb);

	app(-0.5f,  0.5f,  0, fb);
	app( 0.5f,  0.5f,  0, fb);

	fb.flip();

	gl.glBufferData(GL2GL3.GL_ARRAY_BUFFER, 3 * 2 * 4 * 4, fb, GL2GL3.GL_STATIC_DRAW);
	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, 0);

}
 

public void render(int contextID, Renderer renderer,
           Mat4d modelViewMat,
           Camera cam) {

	GL2GL3 gl = renderer.getGL();

	Shader s = renderer.getShader(Renderer.ShaderHandle.HULL);

	int progHandle = s.getProgramHandle();
	gl.glUseProgram(progHandle);

	int modelViewMatVar = gl.glGetUniformLocation(progHandle, "modelViewMat");
	int projMatVar = gl.glGetUniformLocation(progHandle, "projMat");

	int cVar = gl.glGetUniformLocation(progHandle, "C");
	int fcVar = gl.glGetUniformLocation(progHandle, "FC");

	int[] is = new int[2];
	gl.glGenBuffers(2, is, 0);
	int vertexBuffer = is[0];
	int indexBuffer = is[1];

	List<Vec3d> verts = _hull.getVertices();
	// Generate the vertex buffer
	FloatBuffer fb = FloatBuffer.allocate(verts.size() * 3); //
	for (Vec3d v : verts) {
		RenderUtils.putPointXYZ(fb, v);
	}
	fb.flip();

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, vertexBuffer);
	gl.glBufferData(GL2GL3.GL_ARRAY_BUFFER, verts.size() * 3 * 4, fb, GL2GL3.GL_STATIC_DRAW);

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, 0);

	// Generate the index buffer
	List<ConvexHull.HullFace> faces = _hull.getFaces();

	int numIndices = faces.size() * 3;

	IntBuffer ib = IntBuffer.allocate(faces.size() * 3); //
	for (ConvexHull.HullFace f : faces) {
		ib.put(f.indices, 0 ,3);
	}

	ib.flip();

	gl.glBindBuffer(GL2GL3.GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
	gl.glBufferData(GL2GL3.GL_ELEMENT_ARRAY_BUFFER, faces.size() * 3 * 4, ib, GL2GL3.GL_STATIC_DRAW);

	gl.glBindBuffer(GL2GL3.GL_ELEMENT_ARRAY_BUFFER, 0);

	if (!_vaoMap.containsKey(contextID)) {
		setupVAO(contextID, renderer, progHandle, vertexBuffer, indexBuffer);
	}

	int vao = _vaoMap.get(contextID);
	gl.glBindVertexArray(vao);

	gl.glUseProgram(progHandle);

	// Setup uniforms for this object
	Mat4d projMat = cam.getProjMat4d();

	gl.glUniformMatrix4fv(modelViewMatVar, 1, false, RenderUtils.MarshalMat4d(modelViewMat), 0);
	gl.glUniformMatrix4fv(projMatVar, 1, false, RenderUtils.MarshalMat4d(projMat), 0);

	gl.glUniform1f(cVar, Camera.C);
	gl.glUniform1f(fcVar, Camera.FC);

	// Actually draw it

	gl.glEnable(GL2GL3.GL_BLEND);
	gl.glEnable(GL2GL3.GL_CULL_FACE);
	gl.glCullFace(GL2GL3.GL_BACK);

	gl.glBlendFunc(GL2GL3.GL_ONE, GL2GL3.GL_ONE_MINUS_SRC_ALPHA);
	gl.glBlendEquation(GL2GL3.GL_FUNC_ADD);

	gl.glDisable(GL2GL3.GL_DEPTH_TEST);

	//gl.glPolygonMode(GL2GL3.GL_FRONT_AND_BACK, GL2GL3.GL_LINE);

	gl.glDrawElements(GL2GL3.GL_TRIANGLES, numIndices, GL2GL3.GL_UNSIGNED_INT, 0);

	//gl.glPolygonMode(GL2GL3.GL_FRONT_AND_BACK, GL2GL3.GL_FILL);

	gl.glEnable(GL2GL3.GL_DEPTH_TEST);

	gl.glDisable(GL2GL3.GL_CULL_FACE);
	gl.glCullFace(GL2GL3.GL_BACK);

	gl.glDisable(GL2GL3.GL_BLEND);

	gl.glBindVertexArray(0);

	gl.glDeleteBuffers(2, is, 0);

}