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

private void renderFill(GL2GL3 gl) {
	if (_tessPoints == null) {
		_tessPoints = SimpleTess.tesselate(_points);

		fb = FloatBuffer.allocate(3 * _tessPoints.size());
		for (Vec3d vert : _tessPoints) {
			RenderUtils.putPointXYZ(fb, vert);
		}
		fb.flip();
	}

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, _vertBuffer);
	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_CULL_FACE);
	gl.glDrawArrays(GL2GL3.GL_TRIANGLES, 0, _tessPoints.size());
	gl.glEnable(GL2GL3.GL_CULL_FACE);

}
 

private void renderOutline(GL2GL3 gl) {
	// The vertex list is just the closed loop of points
	if (lineWidth == 0) {
		return;
	}

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, _vertBuffer);
	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);

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

	gl.glDrawArrays(GL2GL3.GL_LINE_LOOP, 0, _points.size());

	gl.glLineWidth(1.0f);

}
 

private void updateTexCoordBuffer(Renderer renderer) {
	GL2GL3 gl = renderer.getGL();
	int texCoordBuffSize = _texCoords.size()*2*4;
	_texCoordHandle = renderer.getTexMemManager().allocateBuffer(texCoordBuffSize, gl);
	int buffID = _texCoordHandle.bind();

	FloatBuffer texData = FloatBuffer.allocate(_texCoords.size()*2);

	for (Vec2d v : _texCoords) {
		texData.put((float)v.x); texData.put((float)v.y);
	}
	texData.flip();
	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, buffID);
	gl.glBufferData(GL2GL3.GL_ARRAY_BUFFER, texCoordBuffSize, texData, GL2GL3.GL_STATIC_DRAW);

	int texCoordVar = gl.glGetAttribLocation(progHandle, "texCoord");
	gl.glEnableVertexAttribArray(texCoordVar);

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, buffID);
	gl.glVertexAttribPointer(texCoordVar, 2, GL2GL3.GL_FLOAT, false, 0, 0);

}
 

private void setupVAO(int contextID, Renderer renderer) {
	GL2GL3 gl = renderer.getGL();

	int vao = renderer.generateVAO(contextID, gl);
	VAOMap.put(contextID, vao);

	gl.glBindVertexArray(vao);


	// Position
	int posVar = gl.glGetAttribLocation(progHandle, "position");
	gl.glEnableVertexAttribArray(posVar);

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, vertBuff);
	gl.glVertexAttribPointer(posVar, 3, GL2GL3.GL_FLOAT, false, 0, 0);

	// Normals
	int normalVar = gl.glGetAttribLocation(progHandle, "normal");
	gl.glEnableVertexAttribArray(normalVar);

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, normalBuff);
	gl.glVertexAttribPointer(normalVar, 3, GL2GL3.GL_FLOAT, false, 0, 0);

	// TexCoords
	if (_texCoords == null) {
		// Use default buffer if custom coords have not been included
		int texCoordVar = gl.glGetAttribLocation(progHandle, "texCoord");
		gl.glEnableVertexAttribArray(texCoordVar);

		gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, texCoordBuff);
		gl.glVertexAttribPointer(texCoordVar, 2, GL2GL3.GL_FLOAT, false, 0, 0);

		gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, 0);
	}
	gl.glBindVertexArray(0);

}
 

@Override
public void render(int contextID, Renderer renderer,
	double windowWidth, double windowHeight, Camera cam, Ray pickRay) {


	Vec3d renderedSize = _font.getStringSize(_height, _contents);
	double x = _x;
	double y = _y;
	if (_alignRight) {
		x = windowWidth - _x - renderedSize.x;
	}
	if (!_alignBottom) {
		y = windowHeight - _y - renderedSize.y;
	}


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

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

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

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

	int offsetVar = gl.glGetUniformLocation(prog, "offset");

	float scaleY = (float)(2 * _height / (windowHeight * _font.getNominalHeight()));
	float scaleX = scaleY * (float)(windowHeight/windowWidth);

	int scaleVar = gl.glGetUniformLocation(prog, "scale");
	gl.glUniform2f(scaleVar, scaleX, scaleY);

	float offsetX = (float)(2*x/windowWidth - 1);
	float offsetY = (float)(2*y/windowHeight - 1);

	gl.glDisable(GL2GL3.GL_CULL_FACE);

	for (int cp : RenderUtils.stringToCodePoints(_contents)) {
		TessChar tc = _font.getTessChar(cp);
		if (tc == null) {
			assert(false);
			continue;
		}

		gl.glUniform2f(offsetVar, offsetX, offsetY);

		gl.glDrawArrays(GL2GL3.GL_TRIANGLES, tc.getStartIndex(), tc.getNumVerts());

		offsetX += tc.getAdvance()*scaleX;
	}

	gl.glEnable(GL2GL3.GL_CULL_FACE);
}
 

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

/**
 * Note: render() and renderForView() are mutually non-reentrant due to shared temporaries. This should be fine
 * because neither should ever be called by any thread other than the render thread.
 */
@Override
public void render(int contextID, Renderer renderer, double windowWidth,
		double windowHeight, 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.OVERLAY_FONT);

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

	// Work out the billboard position
	cam.getViewMat4d(tempViewMat);
	// Build up the projection*view matrix
	tempViewMat.mult4(cam.getProjMat4d(), tempViewMat);

	tempPos.x = _pos.x;
	tempPos.y = _pos.y;
	tempPos.z = _pos.z;
	tempPos.w = 1.0;

	tempPos.mult4(tempViewMat, tempPos);
	tempPos.x /= tempPos.w;
	tempPos.y /= tempPos.w;
	// TempPos x and y are now in normalized coordinate space (after the projection)

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

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

	int offsetVar = gl.glGetUniformLocation(prog, "offset");

	float scaleY = (float)(2 * _height / (windowHeight * _font.getNominalHeight()));
	float scaleX = scaleY * (float)(windowHeight/windowWidth);

	int scaleVar = gl.glGetUniformLocation(prog, "scale");
	gl.glUniform2f(scaleVar, scaleX, scaleY);

	float offsetX = (float)tempPos.x;
	float offsetY = (float)tempPos.y;

	offsetX += _xOffset*2.0/windowWidth;
	offsetY += _yOffset*2.0/windowHeight;

	gl.glDisable(GL2GL3.GL_CULL_FACE);

	for (int cp : RenderUtils.stringToCodePoints(_contents)) {
		TessChar tc = _font.getTessChar(cp);
		if (tc == null) {
			assert(false);
			continue;
		}

		gl.glUniform2f(offsetVar, offsetX, offsetY);

		gl.glDrawArrays(GL2GL3.GL_TRIANGLES, tc.getStartIndex(), tc.getNumVerts());

		offsetX += tc.getAdvance()*scaleX;
	}

	gl.glEnable(GL2GL3.GL_CULL_FACE);

}
 

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

}
 

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

}
 

private void setupVAOForStaticLines(int contextID, Renderer renderer) {
	GL2GL3 gl = renderer.getGL();

	int vao = renderer.generateVAO(contextID, gl);
	_lineVAOs.put(contextID, vao);
	gl.glBindVertexArray(vao);

	Shader s= renderer.getShader(ShaderHandle.DEBUG_BATCH);
	assert(s.isGood());
	int prog = s.getProgramHandle();
	gl.glUseProgram(prog);

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

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, linePosBuffer);
	gl.glVertexAttribPointer(posVar, 3, GL2GL3.GL_FLOAT, false, 0, 0);

	int colVar = gl.glGetAttribLocation(prog, "vertColor");
	gl.glEnableVertexAttribArray(colVar);

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, lineInstColorBuffer);
	gl.glVertexAttribPointer(colVar, 4, GL2GL3. GL_UNSIGNED_BYTE, true, 0, 0);
	gl.glVertexAttribDivisor(colVar, 1);

	int instMatVar = gl.glGetAttribLocation(prog, "instMat");
	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, lineTransBuffer);

	for (int i = 0; i < 4; ++i) {
		// Enable 4 variables because this is a matrix
		int varInd = instMatVar + i;

		gl.glEnableVertexAttribArray(varInd);

		gl.glVertexAttribPointer(varInd, 4, GL2GL3.GL_FLOAT, false, 16*4, i*4*4);
		gl.glVertexAttribDivisor(varInd, 1); // Per instance
	}

	gl.glBindVertexArray(0);

}
 

private void setupVAOForSubLine(int contextID, SubLine sub, Renderer renderer) {
	GL2GL3 gl = renderer.getGL();

	int vao = renderer.generateVAO(contextID, gl);
	sub.vaoMap.put(contextID, vao);
	gl.glBindVertexArray(vao);

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

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

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, sub._vertexBuffer);
	gl.glVertexAttribPointer(posVar, 3, GL2GL3.GL_FLOAT, false, 0, 0);

	gl.glBindVertexArray(0);

}
 

private void setupVAOForSubMeshImp(int contextID, int shaderID, SubMesh sub, Renderer renderer) {
	GL2GL3 gl = renderer.getGL();

	int vao = renderer.generateVAO(contextID, gl);
	sub.vaoMaps[shaderID].put(contextID, vao);
	gl.glBindVertexArray(vao);

	int progHandle = sInfos[shaderID].meshProgHandle;
	gl.glUseProgram(progHandle);

	int texCoordVar = gl.glGetAttribLocation(progHandle, "texCoord");

	// For some shaders the texCoordVar may be optimized away
	if (texCoordVar != -1) {
		if (sub._texCoordBuffer != 0) {
			// Texture coordinates
			gl.glEnableVertexAttribArray(texCoordVar);

			gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, sub._texCoordBuffer);
			gl.glVertexAttribPointer(texCoordVar, 2, GL2GL3.GL_FLOAT, false, 0, 0);
		} else {
			gl.glVertexAttrib2f(texCoordVar, 0, 0);
		}
	}

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

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, sub._vertexBuffer);
	gl.glVertexAttribPointer(posVar, 3, GL2GL3.GL_FLOAT, false, 0, 0);

	// Normals
	int normalVar = gl.glGetAttribLocation(progHandle, "normal");
	gl.glEnableVertexAttribArray(normalVar);

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, sub._normalBuffer);
	gl.glVertexAttribPointer(normalVar, 3, GL2GL3.GL_FLOAT, false, 0, 0);

	if (!flattenBuffers) {
		gl.glBindBuffer(GL2GL3.GL_ELEMENT_ARRAY_BUFFER, sub._indexBuffer);
	}

	gl.glBindVertexArray(0);

}
 

private void setupVAO(int contextID, Renderer renderer, int progHandle, int vertexBuffer, int indexBuffer) {
	GL2GL3 gl = renderer.getGL();

	int vao = renderer.generateVAO(contextID, gl);

	_vaoMap.put(contextID, vao);
	gl.glBindVertexArray(vao);

	gl.glUseProgram(progHandle);

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

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, vertexBuffer);
	gl.glVertexAttribPointer(posVar, 3, GL2GL3.GL_FLOAT, false, 0, 0);

	gl.glBindBuffer(GL2GL3.GL_ELEMENT_ARRAY_BUFFER, indexBuffer);

	gl.glBindVertexArray(0);

}
 

private void setupVAO(int contextID, Renderer renderer) {
	GL2GL3 gl = renderer.getGL();

	int vao = renderer.generateVAO(contextID, gl);
	VAOMap.put(contextID, vao);

	gl.glBindVertexArray(vao);


	// Position
	int posVar = gl.glGetAttribLocation(progHandle, "position");
	gl.glEnableVertexAttribArray(posVar);

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, vertBuff);
	gl.glVertexAttribPointer(posVar, 3, GL2GL3.GL_FLOAT, false, 0, 0);

	// TexCoords
	int texCoordVar = gl.glGetAttribLocation(progHandle, "texCoordVert");
	gl.glEnableVertexAttribArray(texCoordVar);

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, texCoordBuff);
	gl.glVertexAttribPointer(texCoordVar, 2, GL2GL3.GL_FLOAT, false, 0, 0);

	gl.glBindVertexArray(0);
}
 

private void setupVAO(int contextID, Renderer renderer) {
	GL2GL3 gl = renderer.getGL();

	int vao = renderer.generateVAO(contextID, gl);
	VAOMap.put(contextID, vao);

	gl.glBindVertexArray(vao);


	// Position
	int posVar = gl.glGetAttribLocation(progHandle, "position");
	gl.glEnableVertexAttribArray(posVar);

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, vertBuff);
	gl.glVertexAttribPointer(posVar, 3, GL2GL3.GL_FLOAT, false, 0, 0);

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, 0);

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

@Override
public void render(int contextID, Renderer renderer,
	double windowWidth, double windowHeight, Camera cam, Ray pickRay) {

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

	GL2GL3 gl = renderer.getGL();

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

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

	gl.glUseProgram(progHandle);

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

	gl.glUniform1i(hasTexVar, 0);


	// Set the size and offset in normalized (-1, 1) coordinates
	double scaleX = 2.0 / windowWidth;
	double scaleY = 2.0 / windowHeight;

	double pixelWidth = 2.0/windowWidth;
	double pixelHeight = 2.0/windowHeight;

	double xOffset = -1.0 + 0.5*pixelWidth;
	double yOffset = -1.0 + 0.5*pixelHeight;

	if (originTop) {
		scaleY *= -1.0;
		yOffset = 1.0 - 0.5*pixelHeight;
	}

	if (originRight) {
		scaleX *= -1.0;
		xOffset = 1.0 - 0.5*pixelWidth;
	}

	gl.glUniform2f(offsetVar, (float)xOffset, (float)yOffset);
	gl.glUniform2f(sizeVar, (float)scaleX, (float)scaleY);

	gl.glEnableVertexAttribArray(posVar);

	gl.glDisable(GL2GL3.GL_CULL_FACE);

	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, lineGLBuff);
	gl.glBufferData(GL2GL3.GL_ARRAY_BUFFER, lineBuffer.limit() * 4, lineBuffer, GL2GL3.GL_STATIC_DRAW);

	gl.glVertexAttribPointer(posVar, 2, GL2GL3.GL_FLOAT, false, 0, 0);

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, 0);

	gl.glDrawArrays(GL2GL3.GL_LINES, 0, lineBuffer.limit() / 2);

	gl.glLineWidth(1.0f);

	gl.glEnable(GL2GL3.GL_CULL_FACE);

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

@Override
public void render(int contextID, Renderer renderer,
	double windowWidth, double windowHeight, Camera cam, Ray pickRay) {

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

	GL2GL3 gl = renderer.getGL();

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

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

	gl.glUseProgram(progHandle);

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

	gl.glUniform1i(hasTexVar, 0);


	// Set the size and offset in normalized (-1, 1) coordinates
	double scaleX = 2.0 / windowWidth;
	double scaleY = 2.0 / windowHeight;

	double pixelWidth = 2.0/windowWidth;
	double pixelHeight = 2.0/windowHeight;

	double xOffset = -1.0 + 0.5*pixelWidth;
	double yOffset = -1.0 + 0.5*pixelHeight;

	if (originTop) {
		scaleY *= -1.0;
		yOffset = 1.0 - 0.5*pixelHeight;
	}

	if (originRight) {
		scaleX *= -1.0;
		xOffset = 1.0 - 0.5*pixelWidth;
	}

	gl.glUniform2f(offsetVar, (float)xOffset, (float)yOffset);
	gl.glUniform2f(sizeVar, (float)scaleX, (float)scaleY);

	gl.glEnableVertexAttribArray(posVar);

	gl.glDisable(GL2GL3.GL_CULL_FACE);

	// Build up a float buffer to pass to GL

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, glBuff);
	gl.glBufferData(GL2GL3.GL_ARRAY_BUFFER, pointsBuffer.limit() * 4, pointsBuffer, GL2GL3.GL_STATIC_DRAW);

	gl.glVertexAttribPointer(posVar, 2, GL2GL3.GL_FLOAT, false, 0, 0);

	gl.glBindBuffer(GL2GL3.GL_ARRAY_BUFFER, 0);

	gl.glDrawArrays(GL2GL3.GL_TRIANGLE_FAN, 0, pointsBuffer.limit() / 2);

	gl.glEnable(GL2GL3.GL_CULL_FACE);

	gl.glBindVertexArray(0);
}