Java GL2.glPushMatrix方法代码示例

import javax.media.opengl.GL2; //导入方法依赖的package包/类
private Vector3f drawVertex(Vector3f vert, double size, float[] color, GL2 gl, GLUT glut) {
    gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL2.GL_AMBIENT, color, 0);
    gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL2.GL_DIFFUSE, color, 0);
    gl.glMaterialf(GL.GL_FRONT_AND_BACK, GL2.GL_SHININESS, 10);

    gl.glPushAttrib(GL2.GL_LIGHTING_BIT);
    gl.glDisable(GL2.GL_TEXTURE_2D);
    gl.glEnable(GL2.GL_LIGHTING);

    gl.glPushMatrix();
    gl.glTranslatef(vert.getX(), vert.getY(), vert.getZ());

    glut.glutSolidSphere(size, 20, 20);
    gl.glPopMatrix();

    gl.glEnable(GL2.GL_TEXTURE_2D);
    gl.glDisable(GL2.GL_LIGHTING);
    gl.glPopAttrib();

    return vert;
}
 

import javax.media.opengl.GL2; //导入方法依赖的package包/类
private void drawCylinder(Vector3f from, Vector3f to, GL2 gl, GLUT glut) {
    Vector3f zAxis = new Vector3f(0, 0, 1);
    Vector3f vector = new Vector3f(to.x - from.x, to.y - from.y, to.z - from.z);
    float length = vector.length();
    vector.normalize();
    float angle = zAxis.angle(vector);
    Vector3f axis = new Vector3f();
    axis.cross(zAxis, vector);
    float convert = (float) (180f / Math.PI);

    gl.glPushMatrix();

    gl.glTranslatef(from.x, from.y, from.z);
    gl.glRotatef(angle * convert, axis.x, axis.y, axis.z);
    glut.glutSolidCylinder(info.getPointSize() / 4.5, length - info.getPointSize(), 20, 20);
    gl.glPopMatrix();

}
 

import javax.media.opengl.GL2; //导入方法依赖的package包/类
private void drawCylinder(GLUT glut, GL2 gl, Vector3f from, Vector3f to) {

        Vector3f zAxis = new Vector3f(0, 0, 1);
        Vector3f vector1 = new Vector3f(to.x - from.x, to.y - from.y, to.z - from.z);
        float length = vector1.length();
        vector1.normalize();
        float angle = zAxis.angle(vector1);
        Vector3f axis = new Vector3f();
        axis.cross(zAxis, vector1);
        float convert = (float) (180f / Math.PI);

        gl.glPushMatrix();
        gl.glTranslatef(from.x, from.y, from.z);
        gl.glRotatef(angle * convert, axis.x, axis.y, axis.z);
        glut.glutSolidCylinder(0.5f, length - 0.5f, 20, 5);
        //glut.glutSolidCylinder(0.5f, 10, 20, 5);
        gl.glPopMatrix();

    }
 

import javax.media.opengl.GL2; //导入方法依赖的package包/类
/**
 *
 * @param gl
 * @param dropFaces faces to be hidden when rendering model.
 */
public void drawWithoutTextures(GL2 gl, ArrayList<Integer> dropFaces) {

    gl.glPushMatrix();
    gl.glPushAttrib(GL2.GL_LIGHTING_BIT);
    for (int i = 0; i < faces.getNumFaces(); i++) {

        gl.glDisable(GL2.GL_TEXTURE_2D);
        gl.glEnable(GL2.GL_LIGHTING);

        faces.renderFace(i, flipTexCoords, gl);

        gl.glEnable(GL2.GL_TEXTURE_2D);
        gl.glDisable(GL2.GL_LIGHTING);

    }
    gl.glPopAttrib();
    gl.glPopMatrix();

}
 

import javax.media.opengl.GL2; //导入方法依赖的package包/类
@Override
protected void renderVis( final GLAutoDrawable drawable )
{
	if( drawable == null || this.axesRenderer == null ) return;

	final GL2 gl = drawable.getGL().getGL2();

	this.axesRenderer.renderAxis( drawable );

	final List<LocatedObject3D<D>> x = new ArrayList<XYZVisualisation3D.LocatedObject3D<D>>();
	x.addAll( this.data );
	for( final LocatedObject3D<D> d : x )
	{
		gl.glPushMatrix();
		this.plotter.plotObject( drawable, d, this.axesRenderer );
		gl.glPopMatrix();
	}
}
 

import javax.media.opengl.GL2; //导入方法依赖的package包/类
/**
 * Draws the terrain.
 *
 * @param gl       The instance of GL2 responsible for drawing the body.
 * @param glut     An instance of GLUT that can be optionally used to assist
 *                 in drawing.
 * @param camPos   The position of the camera in world coordinates.
 * @param lighting The Lighting instance responsible for calculating the
 *                 lighting in this scene. Can be used to set the colours of
 *                 bodies before drawing them.
 */
public void draw(GL2 gl, GLUT glut, Vector camPos, Lighting lighting) {
    gl.glPushMatrix();
    {
        gl.glTranslated(TERRAIN_LEVEL.x(), TERRAIN_LEVEL.y(), TERRAIN_LEVEL.z());
        gl.glEnable(GL_CULL_FACE);
        lighting.setMaterial(gl, Material.DIRT, true);
        terrainBody.draw(gl);
        lighting.setMaterial(gl, Material.WATER);
        waterBody.draw(gl);
        gl.glDisable(GL_CULL_FACE);
        final Vector camPosRelativeToTerrain = camPos.subtract(TERRAIN_LEVEL);
        trees.stream().forEach((tree) -> tree.draw(gl, camPosRelativeToTerrain, lighting));
    }
    gl.glPopMatrix();
}
 

import javax.media.opengl.GL2; //导入方法依赖的package包/类
public void display(GLAutoDrawable drawable) 
{
  GL2 gl = drawable.getGL().getGL2();
  switch(cmd)
    {
    case UPDATE:
      drawScene(gl);
      break;
    case SELECT:
      int buffsize = 512;
      double x = (double) mouse_x, y = (double) mouse_y;
      int[] viewPort = new int[4];
      IntBuffer selectBuffer = Buffers.newDirectIntBuffer(buffsize);
      int hits = 0;
      gl.glGetIntegerv(GL2.GL_VIEWPORT, viewPort, 0);
      gl.glSelectBuffer(buffsize, selectBuffer);
      gl.glRenderMode(GL2.GL_SELECT);
      gl.glInitNames();
      gl.glMatrixMode(GL2.GL_PROJECTION);
      gl.glPushMatrix();
      gl.glLoadIdentity();
      glu.gluPickMatrix(x, (double) viewPort[3] - y, 5.0d, 5.0d, viewPort, 0);
      glu.gluOrtho2D(0.0d, 1.0d, 0.0d, 1.0d);
      drawScene(gl);
      gl.glMatrixMode(GL2.GL_PROJECTION);
      gl.glPopMatrix();
      gl.glFlush();
      hits = gl.glRenderMode(GL2.GL_RENDER);
      processHits(hits, selectBuffer);
      cmd = UPDATE;
      break;
    }
}
 

import javax.media.opengl.GL2; //导入方法依赖的package包/类
private void beginDrawLasso(DrawContext dc) {
	//GL gl = dc.getGL();
	GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.

	int attributeMask =
		GL.GL_DEPTH_BUFFER_BIT // for depth test, depth mask and depth func
			| GL2.GL_TRANSFORM_BIT // for modelview and perspective
			| GL2.GL_VIEWPORT_BIT // for depth range
			| GL2.GL_CURRENT_BIT // for current color
			| GL2.GL_COLOR_BUFFER_BIT // for alpha test func and ref, and blend
			| GL2.GL_DEPTH_BUFFER_BIT // for depth func
			| GL2.GL_ENABLE_BIT; // for enable/disable changes
	gl.glPushAttrib(attributeMask);

	// Apply the depth buffer but don't change it.
	gl.glEnable(GL.GL_DEPTH_TEST);
	gl.glDepthFunc(GL.GL_ALWAYS);
	gl.glDepthMask(false);

	// Load a parallel projection with dimensions (viewportWidth, viewportHeight)
	int[] viewport = new int[4];
	gl.glGetIntegerv(GL.GL_VIEWPORT, viewport, 0);
	gl.glMatrixMode(GL2.GL_PROJECTION);
	gl.glPushMatrix();
	gl.glLoadIdentity();
	gl.glOrtho(0d, viewport[2], 0d, viewport[3], -1d, 1d);

	gl.glMatrixMode(GL2.GL_MODELVIEW);
	gl.glPushMatrix();
}
 

import javax.media.opengl.GL2; //导入方法依赖的package包/类
/**
 *
 * @param openGl
 */
public void displace(final GL2 openGl) {
    openGl.glPushMatrix();
    openGl.glTranslatef(position[0], position[1], position[2]);
    xAxis.rotateAround(openGl);
    yAxis.rotateAround(openGl);
    zAxis.rotateAround(openGl);

}
 

import javax.media.opengl.GL2; //导入方法依赖的package包/类
private void drawArrow(Vector3f from, Vector3f to, float[] color, GL2 gl, GLUT glut) {
    Vector3f zAxis = new Vector3f(0, 0, 1);
    Vector3f vector = new Vector3f(to.x - from.x, to.y - from.y, to.z - from.z);
    float length = vector.length();
    vector.normalize();
    float angle = zAxis.angle(vector);
    Vector3f axis = new Vector3f();
    axis.cross(zAxis, vector);
    float convert = (float) (180f / Math.PI);

    gl.glPushAttrib(GL2.GL_LIGHTING_BIT);
    gl.glDisable(GL2.GL_TEXTURE_2D);
    gl.glEnable(GL2.GL_LIGHTING);

    gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL2.GL_AMBIENT, color, 0);
    gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL2.GL_DIFFUSE, color, 0);
    gl.glMaterialf(GL.GL_FRONT_AND_BACK, GL2.GL_SHININESS, 10);

    gl.glPushMatrix();

    gl.glTranslatef(from.x, from.y, from.z);
    gl.glRotatef(angle * convert, axis.x, axis.y, axis.z);
    glut.glutSolidCylinder(info.getPointSize() / 3, length - info.getPointSize(), 20, 20);
    gl.glTranslatef(0, 0, length - info.getPointSize());
    glut.glutSolidCone(info.getPointSize(), info.getPointSize(), 20, 20);

    gl.glPopMatrix();

    gl.glEnable(GL2.GL_TEXTURE_2D);
    gl.glDisable(GL2.GL_LIGHTING);
    gl.glPopAttrib();
}
 

import javax.media.opengl.GL2; //导入方法依赖的package包/类
public void drawForShaders(GL2 gl, ArrayList<VertexInfo> info, int shaderVertices, int shaderNormals, int shaderPrincipal, int shaderSecondary) {

        gl.glPushMatrix();
        for (int i = 0; i < faces.getNumFaces(); i++) {
            faces.renderFace(i, gl, info, shaderVertices, shaderNormals, shaderPrincipal, shaderSecondary);
        }
        gl.glPopMatrix();

    }
 

import javax.media.opengl.GL2; //导入方法依赖的package包/类
/**
 *
 * @param gl
 */
public void draw(GL2 gl) {
    gl.glPushMatrix();
    gl.glPushAttrib(GL2.GL_LIGHTING_BIT);

    gl.glEnable(GL2.GL_LIGHTING);
    gl.glEnable(GL2.GL_TEXTURE_2D);

    if (materials != null) {
        materials.clearUsedMaterials();
    }
    // render the model face-by-face
    String faceMat;

    for (int i = 0; i < faces.getNumFaces(); i++) {

        faceMat = faces.findMaterial(i);      // get material used by face i
        if (faceMat != null && materials != null) {
            flipTexCoords = materials.renderWithMaterial(faceMat, gl);
        }  // render using that material

        faces.renderFace(i, flipTexCoords, gl);                  // draw face i
    }

    gl.glDisable(GL2.GL_TEXTURE_2D);
    gl.glEnable(GL2.GL_LIGHTING);

    gl.glPopAttrib();
    gl.glPopMatrix();

}
 

import javax.media.opengl.GL2; //导入方法依赖的package包/类
@Override
	public void drawMinorTick( final double location, final AxisConfig<float[]> config )
	{
		final GL2 gl = this.glad.getGL().getGL2();

		gl.glPushMatrix();

		this.orient( gl );

		final float zero = 0.001f;
		gl.glBegin( GL.GL_LINE_STRIP );
		{
//			gl.glEnable( GL2.GL_LINE_STIPPLE );
//			gl.glLineStipple( 2, (short) 0x00FF );
			gl.glLineWidth( (float)config.getRenderingConfig().getMinorTickThickness() );
			gl.glColor3f( config.getRenderingConfig().getMinorTickColour()[0],
					config.getRenderingConfig().getMinorTickColour()[1],
					config.getRenderingConfig().getMinorTickColour()[2] );

			final float l = (float)config.getRenderingConfig().getMinorTickLength();
			final float l2 = -l;

			final float ll = this.calculatePosition( location ).floatValue();

			// We draw in the x axis, so the orientation has to be set appropriately
			gl.glVertex3f( ll, l, zero );
			gl.glVertex3f( ll, l2, zero );
		}
		gl.glEnd();

		gl.glPopMatrix();
	}
 

import javax.media.opengl.GL2; //导入方法依赖的package包/类
@Override
public void draw(GL2 gl, GLUT glut, boolean stickFigure, float tAnim) {
    animation.update(tAnim);
    gl.glPushMatrix();
    {
        final double legHeight = Limb.HEIGHT_OUTER_SEGMENT * Limb.RING_COUNT + Limb.HEIGHT_FOOT;
        gl.glTranslated(0d, 0d, legHeight);

        torso.draw(gl, glut, stickFigure, animation, backNumber);

        gl.glPushMatrix();
        {
            torso.setRightLegMountPoint(gl);
            rightLeg.draw(gl, glut, stickFigure, animation);
        }
        gl.glPopMatrix();
        gl.glPushMatrix();
        {
            torso.setLeftLegMountPoint(gl);
            leftLeg.draw(gl, glut, stickFigure, animation);
        }
        gl.glPopMatrix();
        gl.glPushMatrix();
        {
            torso.setRightArmMountPoint(gl);
            rightArm.draw(gl, glut, stickFigure, animation);
        }
        gl.glPopMatrix();
        gl.glPushMatrix();
        {
            torso.setLeftArmMountPoint(gl);
            leftArm.draw(gl, glut, stickFigure, animation);
        }
        gl.glPopMatrix();
    }
    gl.glPopMatrix();
}
 

import javax.media.opengl.GL2; //导入方法依赖的package包/类
public void drawSegment(GL2 gl, GLUT glut, boolean stickFigure) {
    gl.glPushMatrix();
    if (stickFigure) {
        gl.glTranslated(0d, 0d, HEIGHT_OUTER_SEGMENT / 2f);
        gl.glScaled(RobotBody.STICK_THICKNESS, RobotBody.STICK_THICKNESS, HEIGHT_OUTER_SEGMENT);
        glut.glutSolidCube(1f);
    } else {
        outerSegmentBody.draw(gl);
        final double heightDifference = HEIGHT_OUTER_SEGMENT - HEIGHT_INNER_SEGMENT;
        gl.glTranslated(0d, 0d, heightDifference / 2f);
        innerSegmentBody.draw(gl);
    }
    gl.glPopMatrix();
}