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

private void initUniforms(Renderer renderer, Mat4d modelViewMat, Mat4d projMat, Mat4d viewMat, Mat4d normalMat) {
	GL2GL3 gl = renderer.getGL();

	lightsDirScratch[0].mult4(viewMat, lightsDir[0]);
	lightsDirScratch[1].mult4(viewMat, lightsDir[1]);

	lightsDirFloats[0] = (float)lightsDirScratch[0].x;
	lightsDirFloats[1] = (float)lightsDirScratch[0].y;
	lightsDirFloats[2] = (float)lightsDirScratch[0].z;

	lightsDirFloats[3] = (float)lightsDirScratch[1].x;
	lightsDirFloats[4] = (float)lightsDirScratch[1].y;
	lightsDirFloats[5] = (float)lightsDirScratch[1].z;

	for (int i = 0; i < usedShaders.length; ++i) {
		int shaderID = usedShaders[i];
		ShaderInfo si = sInfos[shaderID];

		gl.glUseProgram(si.meshProgHandle);

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

		gl.glUniform3fv(si.lightDirVar, 2, lightsDirFloats, 0);
		gl.glUniform1fv(si.lightIntVar, 2, lightsInt, 0);
		gl.glUniform1i(si.numLightsVar, numLights);

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

	}
}
 

private void renderImp(int contextID, Renderer renderer, Camera cam, Ray pickRay) {

		if (!staticInit) {
			initStaticBuffers(renderer);
		}

		GL2GL3 gl = renderer.getGL();

		int textureID = _texLoader.getTexID(renderer);

		if (textureID == TexCache.LOADING_TEX_ID) {
			return; // This texture is not ready yet
		}

		if (!VAOMap.containsKey(contextID)) {
			setupVAO(contextID, renderer);
		}

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

		if (	_texCoords != null &&
				(_texCoordHandle == null || !_texCoordHandle.isValid()) ) {
			updateTexCoordBuffer(renderer);
		}

		Mat4d modelViewMat = new Mat4d();

		cam.getViewMat4d(modelViewMat);
		modelViewMat.mult4(_trans.getMat4dRef());
		modelViewMat.scaleCols3(_scale);

		Mat4d normalMat = RenderUtils.getInverseWithScale(_trans, _scale);
		normalMat.transpose4();

		gl.glUseProgram(progHandle);

		gl.glUniformMatrix4fv(modelViewMatVar, 1, false, RenderUtils.MarshalMat4d(modelViewMat), 0);
		gl.glUniformMatrix4fv(projMatVar, 1, false, RenderUtils.MarshalMat4d(cam.getProjMat4d()), 0);
		gl.glUniformMatrix4fv(normalMatVar, 1, false, RenderUtils.MarshalMat4d(normalMat), 0);
		gl.glUniformMatrix4fv(bindSpaceMatVar, 1, false, identMat, 0);
		gl.glUniformMatrix4fv(bindSpaceNorMatVar, 1, false, identMat, 0);

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

		gl.glUniform1i(numLightsVar, 1);
		gl.glUniform3fv(lightDirVar, 1, lightDir, 0);
		gl.glUniform1fv(lightIntVar, 1, lightInt, 0);

		gl.glUniform3f(ambientColorVar, 0.0f, 0.0f, 0.0f);
		gl.glUniform3f(specColorVar, 0.0f, 0.0f, 0.0f);
		gl.glUniform1f(shininessVar, 1.0f);

		gl.glActiveTexture(GL2GL3.GL_TEXTURE0);
		gl.glBindTexture(GL2GL3.GL_TEXTURE_2D, textureID);
		gl.glUniform1i(texVar, 0);
		gl.glTexParameteri(GL2GL3.GL_TEXTURE_2D, GL2GL3.GL_TEXTURE_WRAP_S, GL2GL3.GL_CLAMP_TO_EDGE);
		gl.glTexParameteri(GL2GL3.GL_TEXTURE_2D, GL2GL3.GL_TEXTURE_WRAP_T, GL2GL3.GL_CLAMP_TO_EDGE);

		// Draw
		gl.glDisable(GL2GL3.GL_CULL_FACE);
		gl.glDrawArrays(GL2GL3.GL_TRIANGLES, 0, 6);
		gl.glEnable(GL2GL3.GL_CULL_FACE);

		gl.glBindVertexArray(0);

	}
 

@SuppressWarnings("unused")
private void renderBatch(int contextID, Renderer renderer,
        MeshBatch batch) {

	// TODO bounds
	// TODO size culling


	Material mat = _materials.get(batch.matIndex);
	SubMesh subMesh = _subMeshes.get(batch.meshIndex);

	int shaderID = mat.shaderID | Renderer.STATIC_BATCH_FLAG;

	GL2GL3 gl = renderer.getGL();
	GL4 gl4 = renderer.getGL4();

	if (!batch.vaoMaps[shaderID].containsKey(contextID)) {
		setupVAOForBatch(contextID, batch, renderer);
	}

	int vao = batch.vaoMaps[shaderID].get(contextID);
	gl.glBindVertexArray(vao);

	ShaderInfo si = sInfos[shaderID];

	gl.glUseProgram(si.meshProgHandle);

	// Setup uniforms for this object\
	if (mat._textureIndex != -1) {
		int texHandle = _textureHandles.get(mat._textureIndex);
		gl.glActiveTexture(GL2GL3.GL_TEXTURE0);
		gl.glBindTexture(GL2GL3.GL_TEXTURE_2D, texHandle);
		gl.glTexParameteri(GL2GL3.GL_TEXTURE_2D, GL2GL3.GL_TEXTURE_WRAP_S, GL2GL3.GL_REPEAT);
		gl.glTexParameteri(GL2GL3.GL_TEXTURE_2D, GL2GL3.GL_TEXTURE_WRAP_T, GL2GL3.GL_REPEAT);
		gl.glUniform1i(si.texVar, 0);
	} else {
		gl.glUniform4fv(si.diffuseColorVar, 1, mat._diffuseColor.toFloats(), 0);
	}

	gl.glUniform3fv(si.ambientColorVar, 1, mat._ambientColor.toFloats(), 0);
	gl.glUniform3fv(si.specColorVar, 1, mat._specColor.toFloats(), 0);
	gl.glUniform1f(si.shininessVar, (float)mat._shininess);

	// Actually draw it
	gl.glDisable(GL2GL3.GL_CULL_FACE);

	//gl.glDrawElements(GL2GL3.GL_TRIANGLES, subMesh._numVerts, GL2GL3.GL_UNSIGNED_INT, 0);
	gl4.glDrawElementsInstanced(GL2GL3.GL_TRIANGLES, subMesh._numVerts, GL2GL3.GL_UNSIGNED_INT, 0, batch.numInstances);

	gl.glEnable(GL2GL3.GL_CULL_FACE);

	gl.glBindVertexArray(0);

}
 

private void renderSubMesh(SubMesh subMesh, int materialIndex,
                           Mat4d subInstTrans,
                           Mat4d subInstInvTrans,
                           int contextID,
                           Renderer renderer) {

	Material mat = _materials.get(materialIndex);
	int shaderID = mat.shaderID;

	GL2GL3 gl = renderer.getGL();

	if (!subMesh.vaoMaps[shaderID].containsKey(contextID)) {
		setupVAOForSubMesh(contextID, subMesh, renderer);
	}

	int vao = subMesh.vaoMaps[shaderID].get(contextID);
	gl.glBindVertexArray(vao);

	ShaderInfo si = sInfos[shaderID];

	gl.glUseProgram(si.meshProgHandle);

	// Setup uniforms for this object
	Mat4d subInstNorm = new Mat4d(subInstInvTrans);
	subInstNorm.transpose4();

	gl.glUniformMatrix4fv(si.bindSpaceMatVar, 1, false, RenderUtils.MarshalMat4d(subInstTrans), 0);
	gl.glUniformMatrix4fv(si.bindSpaceNorMatVar, 1, false, RenderUtils.MarshalMat4d(subInstNorm), 0);

	if (mat._textureIndex != -1) {
		int texHandle = _textureHandles.get(mat._textureIndex);
		gl.glActiveTexture(GL2GL3.GL_TEXTURE0);
		gl.glBindTexture(GL2GL3.GL_TEXTURE_2D, texHandle);
		gl.glTexParameteri(GL2GL3.GL_TEXTURE_2D, GL2GL3.GL_TEXTURE_WRAP_S, GL2GL3.GL_REPEAT);
		gl.glTexParameteri(GL2GL3.GL_TEXTURE_2D, GL2GL3.GL_TEXTURE_WRAP_T, GL2GL3.GL_REPEAT);
		gl.glUniform1i(si.texVar, 0);
	} else {
		gl.glUniform4fv(si.diffuseColorVar, 1, mat._diffuseColor.toFloats(), 0);
	}

	gl.glUniform3fv(si.ambientColorVar, 1, mat._ambientColor.toFloats(), 0);
	gl.glUniform3fv(si.specColorVar, 1, mat._specColor.toFloats(), 0);
	gl.glUniform1f(si.shininessVar, (float)mat._shininess);

	if (mat._transType != MeshData.NO_TRANS) {
		gl.glBlendEquationSeparate(GL2GL3.GL_FUNC_ADD, GL2GL3.GL_MAX);

		if (mat._transType != MeshData.DIFF_ALPHA_TRANS) {
			gl.glBlendColor((float)mat._transColour.r,
			                (float)mat._transColour.g,
			                (float)mat._transColour.b,
			                (float)mat._transColour.a);
		}

		if (mat._transType == MeshData.A_ONE_TRANS) {
			gl.glBlendFuncSeparate(GL2GL3.GL_CONSTANT_ALPHA, GL2GL3.GL_ONE_MINUS_CONSTANT_ALPHA, GL2GL3.GL_ONE, GL2GL3.GL_ZERO);
		} else if (mat._transType == MeshData.RGB_ZERO_TRANS) {
			gl.glBlendFuncSeparate(GL2GL3.GL_ONE_MINUS_CONSTANT_COLOR, GL2GL3.GL_CONSTANT_COLOR, GL2GL3.GL_ONE, GL2GL3.GL_ZERO);
		} else if (mat._transType == MeshData.DIFF_ALPHA_TRANS) {
			gl.glBlendFuncSeparate(GL2GL3.GL_SRC_ALPHA, GL2GL3.GL_ONE_MINUS_SRC_ALPHA, GL2GL3.GL_ONE, GL2GL3.GL_ZERO);
		} else {
			assert(false); // Unknown transparency type
		}
	}

	// Actually draw it
	//gl.glPolygonMode(GL2GL3.GL_FRONT_AND_BACK, GL2GL3.GL_LINE);
	gl.glDisable(GL2GL3.GL_CULL_FACE);

	if (flattenBuffers) {
		gl.glDrawArrays(GL2GL3.GL_TRIANGLES, 0, subMesh._numVerts);
	} else {
		gl.glDrawElements(GL2GL3.GL_TRIANGLES, subMesh._numVerts, GL2GL3.GL_UNSIGNED_INT, 0);
	}
	gl.glEnable(GL2GL3.GL_CULL_FACE);

	// Reset the blend state
	if (mat._transType != MeshData.NO_TRANS) {
		gl.glBlendEquationSeparate(GL2GL3.GL_FUNC_ADD, GL2GL3.GL_MAX);
		gl.glBlendFuncSeparate(GL2GL3.GL_SRC_ALPHA, GL2GL3.GL_ONE_MINUS_SRC_ALPHA, GL2GL3.GL_ONE, GL2GL3.GL_ONE);
	}

	gl.glBindVertexArray(0);

}
 

private void renderStaticLines(int contextID, Renderer renderer, Mat4d modelViewMat, Camera cam) {

	if (_lineBatches.size() == 0) {
		return;
	}

	GL2GL3 gl = renderer.getGL();
	GL4 gl4 = renderer.getGL4();

	if (!_lineVAOs.containsKey(contextID)) {
		setupVAOForStaticLines(contextID, renderer);
	}

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

	Shader s = renderer.getShader(ShaderHandle.DEBUG_BATCH);
	int progHandle = s.getProgramHandle();
	gl.glUseProgram(progHandle);

	Mat4d projMat = cam.getProjMat4d();

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

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

	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);

	gl.glLineWidth(1);

	// Actually draw it
	gl4.glBindBuffer(GL4.GL_DRAW_INDIRECT_BUFFER, lineIndirectBuffer);
	gl4.glMultiDrawArraysIndirect(GL2GL3.GL_LINES, 0, _lineBatches.size(), 0);

	//gl.glDrawArrays(GL2GL3.GL_LINES, 0, sub._numVerts);

	gl.glBindVertexArray(0);
}
 

private void initBatchUniforms(Renderer renderer, Mat4d modelViewMat, Mat4d projMat, Mat4d viewMat, Mat4d normalMat) {
	GL2GL3 gl = renderer.getGL();

	lightsDirScratch[0].mult4(viewMat, lightsDir[0]);
	lightsDirScratch[1].mult4(viewMat, lightsDir[1]);

	lightsDirFloats[0] = (float)lightsDirScratch[0].x;
	lightsDirFloats[1] = (float)lightsDirScratch[0].y;
	lightsDirFloats[2] = (float)lightsDirScratch[0].z;

	lightsDirFloats[3] = (float)lightsDirScratch[1].x;
	lightsDirFloats[4] = (float)lightsDirScratch[1].y;
	lightsDirFloats[5] = (float)lightsDirScratch[1].z;

	BatchShaderInfo si = bsInfo;

	gl.glUseProgram(si.progHandle);

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

	gl.glUniform3fv(si.lightDirVar, 2, lightsDirFloats, 0);
	gl.glUniform1fv(si.lightIntVar, 2, lightsInt, 0);
	gl.glUniform1i(si.numLightsVar, numLights);

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

	int[] sampIDs = new int[_textureHandles.size()];
	for (int i = 0; i < sampIDs.length; ++i) {
		sampIDs[i] = i;
	}
	if (sampIDs.length > 0) {
		gl.glUniform1iv(si.diffTexVar, sampIDs.length, sampIDs, 0);
	}

	for (int i = 0; i < _textureHandles.size(); ++i) {
		gl.glActiveTexture(GL2GL3.GL_TEXTURE0+i);
		gl.glBindTexture(GL2GL3.GL_TEXTURE_2D, _textureHandles.get(i));
		gl.glTexParameteri(GL2GL3.GL_TEXTURE_2D, GL2GL3.GL_TEXTURE_WRAP_S, GL2GL3.GL_REPEAT);
		gl.glTexParameteri(GL2GL3.GL_TEXTURE_2D, GL2GL3.GL_TEXTURE_WRAP_T, GL2GL3.GL_REPEAT);
	}
}
 

public static void renderArmature(int contextID, Renderer renderer, Mat4d modelViewMat,
                                  Armature arm, ArrayList<Mat4d> pose, Color4d color, Camera cam) {

	GL2GL3 gl = renderer.getGL();

	if (!_debugVAOMap.containsKey(contextID)) {
		setupDebugVAO(contextID, renderer);
	}

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

	gl.glUseProgram(_debugProgHandle);

	// 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.glUniform4fv(_colorVar, 1, color.toFloats(), 0);

	gl.glUniform1f(_cVar, Camera.C);
	gl.glUniform1f(_fcVar, Camera.FC);

	ArrayList<Armature.Bone> bones = arm.getAllBones();
	//Build up the list of bone vertices
	Vec4d[] vects = new Vec4d[bones.size() * 2];
	for (int i = 0; i < bones.size(); ++i) {
		Armature.Bone b = bones.get(i);

		Vec4d boneStart = new Vec4d(0, 0, 0, 1);
		boneStart.mult4(b.getMatrix(), boneStart);

		Vec4d boneEnd = new Vec4d(0, b.getLength(), 0, 1);
		boneEnd.mult4(b.getMatrix(), boneEnd);

		if (pose != null) {
			// Adjust the bone by the current pose
			Mat4d poseMat = pose.get(i);

			boneStart.mult4(poseMat, boneStart);
			boneEnd.mult4(poseMat, boneEnd);
		}

		vects[2*i + 0] = boneStart;
		vects[2*i + 1] = boneEnd;
	}

	// Now push it to the card
	FloatBuffer fb = FloatBuffer.allocate(vects.length * 3);
	for (Vec4d v : vects) {
		RenderUtils.putPointXYZ(fb, v);
	}
	fb.flip();

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, _lineVertBuffer);
	gl.glBufferData(GL2GL3.GL_ARRAY_BUFFER, fb.limit() * 4, fb, GL2GL3.GL_STATIC_DRAW);

	gl.glVertexAttribPointer(_posVar, 3, GL2GL3.GL_FLOAT, false, 0, 0);

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, 0);

	gl.glDisable(GL2GL3.GL_DEPTH_TEST);
	gl.glDrawArrays(GL2GL3.GL_LINES, 0, fb.limit() / 3);
	gl.glEnable(GL2GL3.GL_DEPTH_TEST);

	gl.glLineWidth(1.0f);

	gl.glBindVertexArray(0);

}
 

public static void renderAABB(int contextID, Renderer renderer,
                              AABB aabb, Color4d color, Camera cam) {

	if (aabb.isEmpty()) {
		return;
	}

	GL2GL3 gl = renderer.getGL();

	if (!_debugVAOMap.containsKey(contextID)) {
		setupDebugVAO(contextID, renderer);
	}

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

	gl.glUseProgram(_debugProgHandle);

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

	Mat4d aabbCenterMat = new Mat4d();
	aabbCenterMat.setTranslate3(aabb.center);
	modelViewMat.mult4(aabbCenterMat);
	modelViewMat.scaleCols3(aabb.radius);

	gl.glUniformMatrix4fv(_modelViewMatVar, 1, false, RenderUtils.MarshalMat4d(modelViewMat), 0);
	gl.glUniformMatrix4fv(_projMatVar, 1, false, RenderUtils.MarshalMat4d(projMat), 0);

	gl.glUniform4fv(_colorVar, 1, color.toFloats(), 0);

	gl.glUniform1f(_cVar, Camera.C);
	gl.glUniform1f(_fcVar, Camera.FC);

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, _aabbVertBuffer);
	gl.glVertexAttribPointer(_posVar, 3, GL2GL3.GL_FLOAT, false, 0, 0);

	gl.glDrawArrays(GL2GL3.GL_LINES, 0, 12 * 2);

	gl.glBindVertexArray(0);

}
 

@Override
public void render(int contextID, Renderer renderer, Camera cam, Ray pickRay) {
	GL2GL3 gl = renderer.getGL();

	if (!VAOMap.containsKey(contextID)) {
		setupVAO(contextID, renderer);
	}

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

	// Render the string
	Shader s = renderer.getShader(Renderer.ShaderHandle.FONT);

	s.useShader(gl);
	int prog = s.getProgramHandle();

	// Setup uniforms for this object
	Mat4d modelViewProjMat = new Mat4d();
	cam.getViewMat4d(modelViewProjMat);
	modelViewProjMat.mult4(_trans);

	Mat4d projMat = cam.getProjMat4d();
	modelViewProjMat.mult4(projMat, modelViewProjMat);

	int modelViewProjMatVar = gl.glGetUniformLocation(prog, "modelViewProjMat");
	gl.glUniformMatrix4fv(modelViewProjMatVar, 1, false, RenderUtils.MarshalMat4d(modelViewProjMat), 0);

	int colorVar = gl.glGetUniformLocation(prog, "color");
	gl.glUniform4fv(colorVar, 1, _color, 0);

	int cVar = gl.glGetUniformLocation(prog, "C");
	gl.glUniform1f(cVar, Camera.C);

	int fcVar = gl.glGetUniformLocation(prog, "FC");
	gl.glUniform1f(fcVar, Camera.FC);

	int advanceVar = gl.glGetUniformLocation(prog, "advance");

	int posVar = gl.glGetAttribLocation(prog, "position");
	gl.glEnableVertexAttribArray(posVar);

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, _font.getGLBuffer(gl));
	gl.glVertexAttribPointer(posVar, 2, GL2GL3.GL_FLOAT, false, 0, 0);
	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, 0);


	// Send out one draw call per character
	float advance = 0;

	gl.glDisable(GL2GL3.GL_CULL_FACE);

	for (int i = 0; i < _contents.length; ++i) {

		gl.glUniform1f(advanceVar, advance);

		gl.glDrawArrays(GL2GL3.GL_TRIANGLES, starts[i], numVerts[i]);

		advance += advances[i];
	}
	gl.glEnable(GL2GL3.GL_CULL_FACE);

	// Cleanup
	gl.glDisableVertexAttribArray(posVar);
}
 

private void renderImp(int contextID, Renderer renderer,
                       Camera cam, Ray pickRay, GL2GL3 gl, float[] renderColour) {


	if (!_VAOMap.containsKey(contextID)) {
		setupVAO(contextID, renderer);
	}

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

	gl.glUseProgram(_progHandle);

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

	modelViewMat.mult4(trans.getMat4dRef());


	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);

	gl.glUniform4fv(_colorVar, 1, renderColour, 0);

	if (isOutline) {
		renderOutline(gl);
	} else {
		renderFill(gl);
	}

	gl.glBindVertexArray(0);

}
 

public static void renderBox(int contextID, Renderer renderer,
           Transform modelTrans, Vec4d scale, Color4d color, Camera cam) {

	GL2GL3 gl = renderer.getGL();

	if (!_debugVAOMap.containsKey(contextID)) {
		setupDebugVAO(contextID, renderer);
	}

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

	gl.glUseProgram(_debugProgHandle);

	gl.glUniform1f(_cVar, Camera.C);
	gl.glUniform1f(_fcVar, Camera.FC);

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

	modelViewMat.mult4(modelTrans.getMat4dRef());
	modelViewMat.scaleCols3(scale);

	gl.glUniformMatrix4fv(_modelViewMatVar, 1, false, RenderUtils.MarshalMat4d(modelViewMat), 0);
	gl.glUniformMatrix4fv(_projMatVar, 1, false, RenderUtils.MarshalMat4d(projMat), 0);

	gl.glUniform4fv(_colorVar, 1, color.toFloats(), 0);

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, _boxVertBuffer);
	gl.glVertexAttribPointer(_posVar, 3, GL2GL3.GL_FLOAT, false, 0, 0);

	gl.glDrawArrays(GL2GL3.GL_LINES, 0, 4 * 2);

	gl.glBindVertexArray(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);

}
 

private void renderSubLine(SubLine sub, int contextID, Renderer renderer,
                           Mat4d modelMat, Mat4d modelViewMat, Mat4d subInstTrans, Camera cam) {

	Mat4d subModelViewMat = new Mat4d();
	Mat4d subModelMat = new Mat4d();

	subModelMat.mult4(modelMat, subInstTrans);

	AABB instBounds = sub._hull.getAABB(subModelMat);
	if (!cam.collides(instBounds)) {
		return;
	}

	subModelViewMat.mult4(modelViewMat, subInstTrans);


	GL2GL3 gl = renderer.getGL();

	if (!sub.vaoMap.containsKey(contextID)) {
		setupVAOForSubLine(contextID, sub, renderer);
	}

	int vao = sub.vaoMap.get(contextID);
	gl.glBindVertexArray(vao);

	int prog = sub._progHandle;
	gl.glUseProgram(prog);

	Mat4d projMat = cam.getProjMat4d();

	gl.glUniformMatrix4fv(sub._modelViewMatVar, 1, false, RenderUtils.MarshalMat4d(subModelViewMat), 0);
	gl.glUniformMatrix4fv(sub._projMatVar, 1, false, RenderUtils.MarshalMat4d(projMat), 0);

	gl.glUniform4fv(sub._colorVar, 1, sub._diffuseColor.toFloats(), 0);

	gl.glUniform1f(sub._cVar, Camera.C);
	gl.glUniform1f(sub._fcVar, Camera.FC);

	gl.glLineWidth(1);

	// Actually draw it
	gl.glDrawArrays(GL2GL3.GL_LINES, 0, sub._numVerts);

	gl.glBindVertexArray(0);

}
 

/**
 * Render a number of lines segments from the points provided
 * @param vaoMap
 * @param renderer
 * @param lineSegments - pairs of discontinuous line start and end points
 * @param color
 * @param cam
 */
public static void renderLine(int contextID, Renderer renderer,
           FloatBuffer lineSegments, float[] color, double lineWidth, Camera cam) {

	GL2GL3 gl = renderer.getGL();

	if (!_debugVAOMap.containsKey(contextID)) {
		setupDebugVAO(contextID, renderer);
	}

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

	gl.glUseProgram(_debugProgHandle);

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


	gl.glUniformMatrix4fv(_modelViewMatVar, 1, false, RenderUtils.MarshalMat4d(modelViewMat), 0);
	gl.glUniformMatrix4fv(_projMatVar, 1, false, RenderUtils.MarshalMat4d(projMat), 0);

	gl.glUniform4fv(_colorVar, 1, color, 0);

	gl.glUniform1f(_cVar, Camera.C);
	gl.glUniform1f(_fcVar, Camera.FC);

	if (!gl.isGLcore())
		gl.glLineWidth((float)lineWidth);
	else
		gl.glLineWidth(1.0f);

	// Build up a float buffer to pass to GL

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, _lineVertBuffer);
	gl.glBufferData(GL2GL3.GL_ARRAY_BUFFER, lineSegments.limit() * 4, lineSegments, GL2GL3.GL_STATIC_DRAW);

	gl.glVertexAttribPointer(_posVar, 3, GL2GL3.GL_FLOAT, false, 0, 0);

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, 0);

	gl.glDrawArrays(GL2GL3.GL_LINES, 0, lineSegments.limit() / 3);

	gl.glLineWidth(1.0f);

	gl.glBindVertexArray(0);
}
 

/**
 * Render a list of points
 * @param vaoMap
 * @param renderer
 * @param points
 * @param color
 * @param pointWidth
 * @param cam
 */
public static void renderPoints(int contextID, Renderer renderer,
           FloatBuffer points, float[] color, double pointWidth, Camera cam) {

	GL2GL3 gl = renderer.getGL();

	if (!_debugVAOMap.containsKey(contextID)) {
		setupDebugVAO(contextID, renderer);
	}

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

	gl.glUseProgram(_debugProgHandle);

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


	gl.glUniformMatrix4fv(_modelViewMatVar, 1, false, RenderUtils.MarshalMat4d(modelViewMat), 0);
	gl.glUniformMatrix4fv(_projMatVar, 1, false, RenderUtils.MarshalMat4d(projMat), 0);

	gl.glUniform4fv(_colorVar, 1, color, 0);

	gl.glUniform1f(_cVar, Camera.C);
	gl.glUniform1f(_fcVar, Camera.FC);

	gl.glPointSize((float)pointWidth);

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, _lineVertBuffer);
	gl.glBufferData(GL2GL3.GL_ARRAY_BUFFER, points.limit() * 4, points, GL2GL3.GL_STATIC_DRAW);

	gl.glVertexAttribPointer(_posVar, 3, GL2GL3.GL_FLOAT, false, 0, 0);

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, 0);

	gl.glDrawArrays(GL2GL3.GL_POINTS, 0, points.limit() / 3);

	gl.glPointSize(1.0f);

	gl.glBindVertexArray(0);
}