Java GL2GL3.glDisable方法代码示例

import com.jogamp.opengl.GL2GL3; //导入方法依赖的package包/类
public void setLineSmoothEnabled(GL2GL3 gl, boolean enabled) {
    if (this.lineSmoothEnabled == enabled) return;

    if (enabled)
        gl.glEnable(GL2GL3.GL_LINE_SMOOTH);
    else
        gl.glDisable(GL2GL3.GL_LINE_SMOOTH);

    this.lineSmoothEnabled = enabled;
}
 

import com.jogamp.opengl.GL2GL3; //导入方法依赖的package包/类
/**
 * Disables the use of the primitive restart index.
 *
 * @param gl the {@code GL2GL3}-Object of the OpenGL context.
 */
public void disable(GL2GL3 gl) {
    if (!enabled) return;
    enabled = false;
    gl.glDisable(GL2.GL_PRIMITIVE_RESTART);
}
 

import com.jogamp.opengl.GL2GL3; //导入方法依赖的package包/类
@Override
public void display(GLAutoDrawable drawable) {
	synchronized (rendererLock) {

		Camera cam = cameras.get(window.getWindowID());

		// The ray of the current mouse position (or null if the mouse is not hovering over the window)
		Ray pickRay = RenderUtils.getPickRay(getMouseInfo(window.getWindowID()));

		PerfInfo pi = new PerfInfo();

		long startNanos = System.nanoTime();

		allowDelayedTextures = true;

		// Cache the current scene. This way we don't need to lock it for the full render
		ArrayList<Renderable> scene = new ArrayList<>(currentScene.size());
		ArrayList<OverlayRenderable> overlay = new ArrayList<>(currentOverlay.size());
		synchronized(sceneLock) {
			scene.addAll(currentScene);
			overlay.addAll(currentOverlay);
		}

		renderScene(drawable.getContext(), window.getWindowID(),
		            scene, overlay,
		            cam, window.getViewableWidth(), window.getViewableHeight(),
		            pickRay, window.getViewID(), pi);

		GL2GL3 gl = drawable.getContext().getGL().getGL2GL3(); // Just to clean up the code below

		boolean showDebug;
		synchronized(settingsLock) {
			showDebug = showDebugInfo;
		}
		if (showDebug) {
			// Draw a window specific performance counter
			gl.glDisable(GL2GL3.GL_DEPTH_TEST);
			drawContext = drawable.getContext();
			StringBuilder perf = new StringBuilder();
			perf.append( String.format( "Objects Culled: %s", pi.objectsCulled) );
			perf.append( String.format( "   VRAM (MB): %.0f", usedVRAM/(1024.0*1024.0)) );
			perf.append( String.format( "   Frame time (ms): %.3f", lastFrameNanos/1000000.0) );
			perf.append( String.format( "   SceneTime (ms): %.3f", sceneTimeNS/1000000.0) );
			perf.append( String.format( "   Loop Time (ms): %.3f", loopTimeNS/1000000.0) );

			TessFont defFont = getTessFont(defaultBoldFontKey);
			OverlayString os = new OverlayString(defFont, perf.toString(), ColourInput.BLACK,
			                                     10, 10, 15, false, false, DisplayModel.ALWAYS);
			os.render(window.getWindowID(), Renderer.this,
			          window.getViewableWidth(), window.getViewableHeight(), cam, null);

			// Also draw this window's debug string
			os = new OverlayString(defFont, window.getDebugString(), ColourInput.BLACK,
			                       10, 10, 30, false, false, DisplayModel.ALWAYS);
			os.render(window.getWindowID(), Renderer.this,
			          window.getViewableWidth(), window.getViewableHeight(), cam, null);

			drawContext = null;
			gl.glEnable(GL2GL3.GL_DEPTH_TEST);

		}

		gl.glFinish();

		long endNanos = System.nanoTime();
		lastFrameNanos = endNanos - startNanos;
	}
}
 

import com.jogamp.opengl.GL2GL3; //导入方法依赖的package包/类
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);


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

	}
 

import com.jogamp.opengl.GL2GL3; //导入方法依赖的package包/类
@Override
public void render(int contextID, Renderer renderer,
		double windowWidth, double windowHeight, Camera cam, Ray pickRay) {

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

	double x = _x;
	double y = _y;
	if (_alignRight) {
		x = windowWidth - _x - _width;
	}
	if (!_alignBottom) {
		y = windowHeight - _y - _height;
	}

	GL2GL3 gl = renderer.getGL();

	int textureID = renderer.getTexCache().getTexID(gl, _imageURI, _isTransparent, _isCompressed, false);

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

	gl.glUseProgram(progHandle);

	gl.glUniform1i(hasTexVar, 1);

	gl.glActiveTexture(GL2GL3.GL_TEXTURE0);
	gl.glBindTexture(GL2GL3.GL_TEXTURE_2D, textureID);
	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);
	gl.glUniform1i(texVar, 0);

	if (_isTransparent) {
		gl.glEnable(GL2GL3.GL_BLEND);
		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);
	}

	// Set the size and scale in normalized (-1, 1) coordinates
	double normX = x / (0.5 *  windowWidth) - 1;
	double normY = y / (0.5 * windowHeight) - 1;

	double normWidth  =  _width / (0.5 *  windowWidth);
	double normHeight = _height / (0.5 * windowHeight);

	gl.glUniform2f(offsetVar, (float)normX, (float)normY);
	gl.glUniform2f(sizeVar, (float)normWidth, (float)normHeight);

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

	if (_isTransparent) {
		gl.glDisable(GL2GL3.GL_BLEND);
	}

}
 

import com.jogamp.opengl.GL2GL3; //导入方法依赖的package包/类
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);

}
 

import com.jogamp.opengl.GL2GL3; //导入方法依赖的package包/类
/**
 * 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);

}
 

import com.jogamp.opengl.GL2GL3; //导入方法依赖的package包/类
@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);
}
 

import com.jogamp.opengl.GL2GL3; //导入方法依赖的package包/类
@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);
}