public void display(GLAutoDrawable drawable) { GL2 gl = drawable.getGL().getGL2(); // double eqn[] = {0.0, 1.0, 0.0, 0.0}; double eqn2[] = {1.0, 0.0, 0.0, 0.0}; gl.glClear(GL.GL_COLOR_BUFFER_BIT); gl.glColor3f(1.0f, 1.0f, 1.0f); gl.glPushMatrix(); gl.glTranslatef(0.0f, 0.0f, -5.0f); /* clip lower half -- y < 0 */ gl.glClipPlane(GL2.GL_CLIP_PLANE0, eqn, 0); gl.glEnable(GL2.GL_CLIP_PLANE0); /* clip left half -- x < 0 */ gl.glClipPlane(GL2.GL_CLIP_PLANE1, eqn2, 0); gl.glEnable(GL2.GL_CLIP_PLANE1); gl.glRotatef(90.0f, 1.0f, 0.0f, 0.0f); glut.glutWireSphere(1.0, 20, 16); gl.glPopMatrix(); gl.glFlush(); }
@SuppressWarnings("unused") private static void drawBox(GL2 gl) { gl.glDisable(GLLightingFunc.GL_LIGHTING); gl.glDisable(GL.GL_TEXTURE_2D); gl.glColor3f(1.0f, 1.0f, 1.0f); gl.glBegin(GL.GL_LINE_STRIP); gl.glVertex3f(-0.5f, -0.5f, 0.5f); gl.glVertex3f(0.5f, -0.5f, 0.5f); gl.glVertex3f(0.5f, 0.5f, 0.5f); gl.glVertex3f(-0.5f, 0.5f, 0.5f); gl.glVertex3f(-0.5f, -0.5f, 0.5f); gl.glVertex3f(-0.5f, -0.5f, -0.5f); gl.glVertex3f(0.5f, -0.5f, -0.5f); gl.glVertex3f(0.5f, 0.5f, -0.5f); gl.glVertex3f(-0.5f, 0.5f, -0.5f); gl.glVertex3f(-0.5f, -0.5f, -0.5f); gl.glEnd(); gl.glBegin(GL.GL_LINE_STRIP); gl.glVertex3f(-0.5f, 0.5f, 0.5f); gl.glVertex3f(-0.5f, 0.5f, -0.5f); gl.glEnd(); gl.glBegin(GL.GL_LINE_STRIP); gl.glVertex3f(0.5f, 0.5f, 0.5f); gl.glVertex3f(0.5f, 0.5f, -0.5f); gl.glEnd(); gl.glBegin(GL.GL_LINE_STRIP); gl.glVertex3f(0.5f, -0.5f, 0.5f); gl.glVertex3f(0.5f, -0.5f, -0.5f); gl.glEnd(); gl.glEnable(GL.GL_TEXTURE_2D); gl.glEnable(GLLightingFunc.GL_LIGHTING); gl.glEnable(GLLightingFunc.GL_LIGHT0); }
@Override public void init(GL2 gl) { displayListIndex = gl.glGenLists(1); gl.glEnable(GL.GL_LINE_SMOOTH); gl.glEnable(GL.GL_BLEND); gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA); }
void setupLight(GL2 gl) { gl.glShadeModel(GL2.GL_SMOOTH); gl.glEnable(GL2.GL_CULL_FACE); gl.glCullFace(GL2.GL_BACK); /* create light 0 and give it a position */ // float light0pos[] = {1.1f, 1.1f, -1.1f, 1}; float light0pos[] = {1f, 1f, 1f, 0}; gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_POSITION, light0pos, 0); /* turn light 0 on */ gl.glEnable(GL2.GL_LIGHT0); gl.glEnable(GL2.GL_RESCALE_NORMAL); float ambient[] = {0.3f, 0.3f, 0.3f}; gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_AMBIENT, ambient, 0); float specular[] = {1f, 1f, 1f, 1}; gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_SPECULAR, specular, 0); gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_SPECULAR, new float[] {0.5f, 0.5f, 0.5f, 1}, 0); gl.glMaterialf(GL2.GL_FRONT_AND_BACK, GL2.GL_SHININESS, 20); /*turn lighting on */ gl.glEnable(GL2.GL_LIGHTING); gl.glClearAccum(0, 0, 0, 0); lightEnabled = true; }
public void setup() { // OPENGL SPECIFIC INITIALIZATION (OPTIONAL) GL2 gl = getGL2(); gl.glEnable(GL2.GL_CULL_FACE); float light_model_ambient[] = {0.3f, 0.3f, 0.3f, 1.0f}; float light0_diffuse[] = {0.9f, 0.9f, 0.9f, 0.9f}; float light0_direction[] = {0.0f, -0.4f, 1.0f, 0.0f}; gl.glEnable(GL2.GL_NORMALIZE); gl.glShadeModel(GL2.GL_SMOOTH); gl.glLightModeli(GL2.GL_LIGHT_MODEL_LOCAL_VIEWER, GL2.GL_FALSE); gl.glLightModeli(GL2.GL_LIGHT_MODEL_TWO_SIDE, GL2.GL_FALSE); gl.glLightModelfv(GL2.GL_LIGHT_MODEL_AMBIENT, light_model_ambient, 0); gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_DIFFUSE, light0_diffuse, 0); gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_POSITION, light0_direction, 0); gl.glEnable(GL2.GL_LIGHT0); gl.glEnable(GL2.GL_COLOR_MATERIAL); gl.glEnable(GL2.GL_LIGHTING); gl.glColor3f(0.9f, 0.9f, 0.9f); gl.glBlendFunc(GL2.GL_SRC_ALPHA, GL2.GL_ONE_MINUS_SRC_ALPHA); background(0, 0, 0); video_frame = new VideoFrame(); }
public void draw() { GL2 gl = getGL2(); pushMatrix(); translate(0, 0, -2); rotate(view_rotx, 1.0, 0.0, 0.0); rotate(view_roty, 0.0, 1.0, 0.0); rotate(view_rotz, 0.0, 0.0, 1.0); translate(0, 0, 2); if (app != null) { if (is_playing) { map_previous = map; map = new DepthMap( app.w, app.h, DepthMap.fromRawDepthFile( new File(app.filename), app.frame_now - 1, app.w, app.h, false)); map.maskZ(app.z_threshold.getValue() / 100f); // map.maskRect(130,40,100,100);//head // map.maskRect(50,140,130,100);//arms map.setUVuniform(); if (app.frame_now < app.frames) { app.frame_now += 1; app.time_domain.setValue(app.frame_now); } else { app.play_button.setText("Play"); stop(); } } } if (map != null) { if (app.show_diff.isSelected() && map != null && map_previous != null) { // map.drawNormals(gl); // gl.glClear(GL2.GL_DEPTH); // gl.glEnable(GL2.GL_BLEND); computeColorMap(); gl.glDisable(GL2.GL_LIGHTING); gl.glEnable(GL2.GL_TEXTURE_2D); gl.glColor4f(1f, 1f, 1f, 0.75f); video_frame.use(gl); map.drawTextureNormals(gl); gl.glDisable(GL2.GL_TEXTURE_2D); gl.glEnable(GL2.GL_LIGHTING); gl.glDisable(GL2.GL_BLEND); } else { gl.glColor3f(0.9f, 0.9f, 0.9f); map.drawNormals(gl); } } popMatrix(); }
@Override public void init(GLAutoDrawable dr) { GL2 gl = dr.getGL().getGL2(); // Задает цвет фона gl.glClearColor(0f, 0f, 0f, 0f); gl.glClearDepth(1.0f); // Интерполирует цвет, если вершины заданы различным цветом gl.glShadeModel(GL2.GL_SMOOTH); // Удаления невидимых линий и поверхностей gl.glEnable(GL.GL_DEPTH_TEST); gl.glDepthFunc(GL.GL_LEQUAL); // Сглаживание gl.glHint(GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST); // Включение отображения текстур gl.glEnable(GL.GL_TEXTURE_2D); try { model = ModelFactory.createModel("model/globalstar/Globalstar.3ds"); model.setUseLighting(false); } catch (Exception e) { System.out.println("Ошибка загрузки модели"); e.printStackTrace(); System.exit(1); } }
@Override public void init(GLAutoDrawable drawable) { GL2 gl = drawable.getGL().getGL2(); // If you do not add this line // opengl will draw things in the order you // draw them in your program gl.glEnable(GL2.GL_DEPTH_TEST); // By enabling lighting, color is worked out differently. gl.glEnable(GL2.GL_LIGHTING); // When you enable lighting you must still actually // turn on a light such as this default light. gl.glEnable(GL2.GL_LIGHT0); // Light property vectors. float lightAmb[] = {0.0f, 0.0f, 0.0f, 1.0f}; float lightDifAndSpec[] = {1.0f, 1.0f, 1.0f, 1.0f}; // float lightPos[] = { 0.0f, 1.5f, 3.0f, 1.0f }; float globAmb[] = {0.2f, 0.2f, 0.2f, 1.0f}; // float globAmb[] = {0.5f,0.5f,0.5f,1f}; // Light properties. gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_AMBIENT, lightAmb, 0); gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_DIFFUSE, lightDifAndSpec, 0); gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_SPECULAR, lightDifAndSpec, 0); // gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_POSITION, lightPos,0); gl.glBlendFunc(GL2.GL_SRC_ALPHA, GL2.GL_ONE_MINUS_SRC_ALPHA); gl.glEnable(GL2.GL_BLEND); }
public void init(GLAutoDrawable drawable) { GL2 gl = drawable.getGL().getGL2(); glut = new GLUT(); // float ambient[] = new float[] {0.0f, 0.0f, 0.0f, 1.0f}; float diffuse[] = new float[] {1.0f, 1.0f, 1.0f, 1.0f}; float specular[] = new float[] {1.0f, 1.0f, 1.0f, 1.0f}; float position[] = new float[] {0.0f, 3.0f, 3.0f, 0.0f}; float lmodel_ambient[] = new float[] {0.2f, 0.2f, 0.2f, 1.0f}; float local_view[] = new float[] {0.0f}; gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_SPECULAR, ambient, 0); gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_DIFFUSE, diffuse, 0); gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_POSITION, position, 0); gl.glLightModelfv(GL2.GL_LIGHT_MODEL_AMBIENT, lmodel_ambient, 0); gl.glLightModelfv(GL2.GL_LIGHT_MODEL_LOCAL_VIEWER, local_view, 0); gl.glFrontFace(GL.GL_CW); gl.glEnable(GL2.GL_LIGHTING); gl.glEnable(GL2.GL_LIGHT0); gl.glEnable(GL2.GL_AUTO_NORMAL); gl.glEnable(GL2.GL_NORMALIZE); gl.glEnable(GL.GL_DEPTH_TEST); gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f); gl.glClearAccum(0.0f, 0.0f, 0.0f, 0.0f); /* make teapot display list */ teapotList = gl.glGenLists(1); gl.glNewList(teapotList, GL2.GL_COMPILE); glut.glutSolidTeapot(0.5f); gl.glEndList(); }
public Light(GL2 gl, Vector3f pos, Vector3f amb, Vector3f dif, Vector3f spec) { position = new float[] {pos.x, pos.y, pos.z, 1}; ambient = new float[] {amb.x, amb.y, amb.z, 1}; diffuse = new float[] {dif.x, dif.y, dif.z, 1}; specular = new float[] {spec.x, spec.y, spec.z, 1}; gl.glEnable(GL2.GL_LIGHT0 + lightNumber); if (lightNumber == 0) // if this is the first light enable lighting gl.glEnable(GL2.GL_LIGHTING); updateLightParameters(gl); }
@Override public void init(GLAutoDrawable drawable) { try { gl = drawable.getGL().getGL2(); gl.glClearColor(0.7f, 0.7f, 0.9f, 1.0f); // gl.setSwapInterval(1); gl.glEnable(GL.GL_DEPTH_TEST); gl.glEnable(GL2.GL_LIGHTING); gl.glEnable(GL.GL_CULL_FACE); gl.glCullFace(GL.GL_BACK); ///////////////////////////////// // carregando e compilando objetos ///////////////////////////////// createSceneObjects(); Iterator<SceneObject> it = scene.getSceneObjectsIterator(); while (it.hasNext()) { SceneObject sceneObject = it.next(); JWavefrontModel[] models = sceneObject.getAnimationModels(); if (models == null) continue; for (JWavefrontModel model : models) { if (sceneObject.useTexture()) model.compile( drawable, JWavefrontModel.WF_MATERIAL | JWavefrontModel.WF_TEXTURE | JWavefrontModel.WF_SMOOTH); else model.compile(drawable, JWavefrontModel.WF_COLOR | JWavefrontModel.WF_SMOOTH); } } // light setSunLight(); // fog setFog(); gl.glMatrixMode(GL2.GL_PROJECTION); gl.glLoadIdentity(); float h = (float) mainFrame.getWidth() / (float) mainFrame.getHeight(); glu.gluPerspective(FPCamera.FOV, h, FPCamera.NEAR, FPCamera.FAR); } catch (IOException ex) { Logger.getLogger(Renderer.class.getName()).log(Level.SEVERE, null, ex); } }
@Override public void render(GL2 gl, float trajectory) { // flat = true; gl.glPushMatrix(); { gl.glTranslatef(c.x, c.y, c.z); gl.glRotatef(trajectory, 0, -1, 0); gl.glRotatef((flat) ? -90 : 0, 1, 0, 0); gl.glRotatef(rotation, 0, 0, 1); Vec3 scale = new Vec3(0.75f, 2.0f, 0); if (miniature) scale = scale.multiply(0.5f); scale = scale.multiply(0.8f); gl.glScalef(scale.x, scale.y, scale.z); gl.glTranslatef(0, 0.2f, 0); gl.glDepthMask(false); gl.glDisable(GL_LIGHTING); gl.glEnable(GL_BLEND); gl.glEnable(GL_TEXTURE_2D); gl.glBlendFunc(GL2.GL_SRC_ALPHA, GL2.GL_ONE); whiteSpark.bind(gl); gl.glColor3f(colors[color][0], colors[color][1], colors[color][2]); gl.glBegin(GL_QUADS); { gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f(-0.5f, -0.5f, 0.0f); gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f(-0.5f, 0.5f, 0.0f); gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f(0.5f, 0.5f, 0.0f); gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f(0.5f, -0.5f, 0.0f); } gl.glEnd(); gl.glDisable(GL_BLEND); gl.glEnable(GL_LIGHTING); gl.glDepthMask(true); gl.glColor3f(1, 1, 1); } gl.glPopMatrix(); }
@Override public void init(GLAutoDrawable drawable) { GL2 gl = drawable.getGL().getGL2(); // If you do not add this line // opengl will draw things in the order you // draw them in your program gl.glEnable(GL2.GL_DEPTH_TEST); gl.glClearColor(1, 1, 1, 1); // Turn on for transparency and blending gl.glBlendFunc(GL2.GL_SRC_ALPHA, GL2.GL_ONE_MINUS_SRC_ALPHA); gl.glEnable(GL2.GL_BLEND); }
private void setSunLight() { float ambient[] = {0.2f, 0.2f, 0.2f, 1.0f}; float diffuse[] = {0.7f, 0.7f, 0.7f, 1.0f}; float specular[] = {1, 1, 1, 1.0f}; float position[] = {0, 16, 10, 1}; gl.glEnable(GL2.GL_LIGHT0); gl.glEnable(GL2.GL_COLOR_MATERIAL); gl.glColorMaterial(GL.GL_FRONT, GL2.GL_AMBIENT_AND_DIFFUSE); gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_AMBIENT, ambient, 0); gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_DIFFUSE, diffuse, 0); gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_SPECULAR, specular, 0); gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_POSITION, position, 0); }
@Override protected void paintColorScale(GL2 gl, Axis1D axis, int width, int height) { if (colorTexture != null && axis instanceof TaggedAxis1D) { TaggedAxis1D taggedAxis = (TaggedAxis1D) axis; colorTexture.prepare(gl, 0); int count = updateCoordinateBuffers(taggedAxis, width, height); gl.glTexEnvf(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, GL2.GL_REPLACE); gl.glPolygonMode(GL2.GL_FRONT, GL2.GL_FILL); gl.glEnable(GL2.GL_TEXTURE_1D); gl.glEnableClientState(GL2.GL_VERTEX_ARRAY); gl.glEnableClientState(GL2.GL_TEXTURE_COORD_ARRAY); gl.glVertexPointer(2, GL2.GL_FLOAT, 0, vertexCoords.rewind()); gl.glTexCoordPointer(1, GL2.GL_FLOAT, 0, textureCoords.rewind()); try { gl.glDrawArrays(GL2.GL_QUAD_STRIP, 0, count); } finally { gl.glDisableClientState(GL2.GL_VERTEX_ARRAY); gl.glDisableClientState(GL2.GL_TEXTURE_COORD_ARRAY); gl.glDisable(GL2.GL_TEXTURE_1D); } } gl.glDisable(GL2.GL_TEXTURE_1D); outlineColorQuad(gl, axis, width, height); }
protected void setBlendingFunction(DrawContext dc) { GL2 gl = dc.getGL().getGL2(); double alpha = this.getOpacity(); gl.glColor4d(alpha, alpha, alpha, alpha); gl.glEnable(GL2.GL_BLEND); gl.glBlendFunc(GL2.GL_SRC_ALPHA, GL2.GL_ONE_MINUS_SRC_ALPHA); }
/** ***************************************************** */ public void draw(GL2 gl, GLU glu, Camera cam) { if (transform != null) transform.execute(gl); gl.glTranslatef(x, y, z); applyMaterial(gl); gl.glLineWidth(wfwidth); // Draw GLUquadric qobj = glu.gluNewQuadric(); if (facestatus) { if (wfstatus) { gl.glEnable(GL2.GL_POLYGON_OFFSET_FILL); gl.glPolygonOffset(1.0f, 1.0f); } gl.glPolygonMode(GL2.GL_FRONT_AND_BACK, GL2.GL_FILL); gl.glNormal3f(norm.x, norm.y, norm.z); gl.glColor4f(color.r, color.g, color.b, color.a); glu.gluDisk(qobj, radiusInner, radiusOuter, slices, loops); if (wfstatus) gl.glDisable(GL2.GL_POLYGON_OFFSET_FILL); } if (wfstatus) { gl.glPolygonMode(GL2.GL_FRONT_AND_BACK, GL2.GL_LINE); gl.glNormal3f(norm.x, norm.y, norm.z); gl.glColor4f(wfcolor.r, wfcolor.g, wfcolor.b, wfcolor.a); glu.gluDisk(qobj, radiusInner, radiusOuter, slices, loops); } }
private void renderBlast(GL2 gl) { GLU glu = new GLU(); Shader shader = Shader.get("dissolve"); if (shader != null) { shader.enable(gl); shader.setSampler(gl, "cloudSampler", 0); shader.setUniform(gl, "dissolveFactor", 1.0f - ((float) blastDuration / 60.0f)); } gl.glEnable(GL2.GL_TEXTURE_2D); GLUquadric sphere = glu.gluNewQuadric(); glu.gluQuadricDrawStyle(sphere, GLU.GLU_FILL); glu.gluQuadricTexture(sphere, true); gl.glPushMatrix(); { noiseSampler.bind(gl); noiseSampler.setTexParameterf(gl, GL2.GL_TEXTURE_MAX_ANISOTROPY_EXT, 16); gl.glTranslatef(bound.c.x, bound.c.y, bound.c.z); glu.gluSphere(sphere, blastRadius, 24, 24); } gl.glPopMatrix(); }
public void init(GLAutoDrawable drawable) { drawable.setGL(new DebugGL2(drawable.getGL().getGL2())); final GL2 gl = drawable.getGL().getGL2(); // drawable.getGL().getGL2(); gl.glViewport(0, 0, SCREENW, SCREENH); // Clear color buffer with black // gl.glClearColor(1.0f, 0.5f, 1.0f, 1.0f); gl.glClearColor(.0f, .0f, .0f, 1.0f); gl.glClearDepth(1.0f); gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT); gl.glEnable(GL2.GL_DEPTH_TEST); gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, 1); gl.glCreateShader(GL2GL3.GL_VERTEX_SHADER); shader.init(gl); int programName = shader.getID(); gl.glBindAttribLocation(programName, Object3D.VERTEXPOSITION, "inposition"); gl.glBindAttribLocation(programName, Object3D.VERTEXCOLOR, "incolor"); gl.glBindAttribLocation(programName, Object3D.VERTEXNORMAL, "innormal"); gl.glBindAttribLocation(programName, Object3D.VERTEXTEXCOORD0, "intexcoord0"); shader.link(gl); uniformMat = gl.glGetUniformLocation(programName, "mat"); uniformLight = gl.glGetUniformLocation(programName, "lightdir"); gl.glUseProgram(programName); gl.glUniform3f(uniformLight, 0f, 10f, -10f); obj.init(gl, mats, programName); gl.glUseProgram(0); }
// Where the printing happens private void glPrint(GL2 gl, int x, int y, int set, String fmt) { // If There's No Text if (fmt == null) { return; } // Did User Choose An Invalid Character Set? if (set > 1) { // If So, Select Set 1 (Italic) set = 1; } gl.glEnable(GL.GL_TEXTURE_2D); // Enable Texture Mapping gl.glLoadIdentity(); // Reset The Modelview Matrix gl.glTranslated(x, y, 0); // Position The Text (0,0 - Top Left) gl.glListBase(base - 32 + (128 * set)); // Choose The Font Set (0 or 1) gl.glScalef(1.0f, 2.0f, 1.0f); // Make The Text 2X Taller if (stringBuffer.capacity() < fmt.length()) { stringBuffer = GLBuffers.newDirectByteBuffer(fmt.length()); } stringBuffer.clear(); stringBuffer.put(fmt.getBytes()); stringBuffer.flip(); // Write the text to the screen gl.glCallLists(fmt.length(), GL.GL_UNSIGNED_BYTE, stringBuffer); gl.glDisable(GL.GL_TEXTURE_2D); // Disable Texture Mapping }
private void setFog() { gl.glEnable(GL2.GL_FOG); gl.glFogf(GL2.GL_FOG_START, 5.0f); gl.glFogf(GL2.GL_FOG_END, 50.0f); gl.glFogfv(GL2.GL_FOG_COLOR, new float[] {0.8f, 0.8f, 0.9f, 1.0f}, 0); gl.glFogi(GL2.GL_FOG_MODE, GL.GL_LINEAR); }
/** Configures the GL light with the light parameters. */ public void turnOn(GL2 gl, int glLight) { if (isGLLight(glLight)) { gl.glEnable(glLight); if (ambient != null) { gl.glLightfv(glLight, GLLightingFunc.GL_AMBIENT, ambient, 0); } else { gl.glLightfv(glLight, GLLightingFunc.GL_AMBIENT, new float[] {0f, 0f, 0f, 0f}, 0); } if (diffuse != null) { gl.glLightfv(glLight, GLLightingFunc.GL_DIFFUSE, diffuse, 0); } else { gl.glLightfv(glLight, GLLightingFunc.GL_DIFFUSE, new float[] {0f, 0f, 0f, 0f}, 0); } if (specular != null) { gl.glLightfv(glLight, GLLightingFunc.GL_SPECULAR, specular, 0); } else { gl.glLightfv(glLight, GLLightingFunc.GL_SPECULAR, new float[] {0f, 0f, 0f, 0f}, 0); } gl.glLightf(glLight, GLLightingFunc.GL_CONSTANT_ATTENUATION, attenuationConstant); gl.glLightf(glLight, GLLightingFunc.GL_LINEAR_ATTENUATION, attenuationLinear); gl.glLightf(glLight, GLLightingFunc.GL_QUADRATIC_ATTENUATION, attenuationQuadratic); switch (type) { case Directional: gl.glLightfv( glLight, GLLightingFunc.GL_POSITION, new float[] {direction.x, direction.y, direction.z, type.w}, 0); break; case Point: gl.glLightfv( glLight, GLLightingFunc.GL_POSITION, new float[] {position.x, position.y, position.z, type.w}, 0); break; case Spot: gl.glLightfv( glLight, GLLightingFunc.GL_POSITION, new float[] {position.x, position.y, position.z, type.w}, 0); gl.glLightfv( glLight, GLLightingFunc.GL_SPOT_DIRECTION, new float[] {direction.x, direction.y, direction.z}, 0); gl.glLightf(glLight, GLLightingFunc.GL_SPOT_CUTOFF, cutoff); gl.glLightf(glLight, GLLightingFunc.GL_SPOT_EXPONENT, spotExp); break; default: // TODO(yin): Maybe custom lights? } } }
protected void beginDrawIcons(DrawContext dc) { GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility. this.oglStackHandler.clear(); int attributeMask = GL2.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 this.oglStackHandler.pushAttrib(gl, attributeMask); // Apply the depth buffer but don't change it. if ((!dc.isDeepPickingEnabled())) gl.glEnable(GL.GL_DEPTH_TEST); gl.glDepthMask(false); // Suppress any fully transparent image pixels gl.glEnable(GL2.GL_ALPHA_TEST); gl.glAlphaFunc(GL2.GL_GREATER, 0.001f); // Load a parallel projection with dimensions (viewportWidth, viewportHeight) this.oglStackHandler.pushProjectionIdentity(gl); gl.glOrtho( 0d, dc.getView().getViewport().width, 0d, dc.getView().getViewport().height, -1d, 1d); this.oglStackHandler.pushModelview(gl); this.oglStackHandler.pushTexture(gl); if (dc.isPickingMode()) { this.pickSupport.beginPicking(dc); // Set up to replace the non-transparent texture colors with the single pick color. gl.glEnable(GL.GL_TEXTURE_2D); gl.glTexEnvf(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, GL2.GL_COMBINE); gl.glTexEnvf(GL2.GL_TEXTURE_ENV, GL2.GL_SRC0_RGB, GL2.GL_PREVIOUS); gl.glTexEnvf(GL2.GL_TEXTURE_ENV, GL2.GL_COMBINE_RGB, GL2.GL_REPLACE); } else { gl.glEnable(GL.GL_TEXTURE_2D); gl.glEnable(GL.GL_BLEND); gl.glBlendFunc(GL.GL_ONE, GL.GL_ONE_MINUS_SRC_ALPHA); } }
/** * Called back immediately after the OpenGL context is initialized. Can be used to perform * one-time initialization. Run only once. */ @Override public void init(GLAutoDrawable drawable) { GL2 gl = drawable.getGL().getGL2(); // get the OpenGL graphics context glu = new GLU(); // get GL Utilities gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // set background (clear) color gl.glClearDepth(1.0f); // set clear depth value to farthest gl.glEnable(GL_DEPTH_TEST); // enables depth testing gl.glDepthFunc(GL_LEQUAL); // the type of depth test to do gl.glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // best perspective correction gl.glShadeModel(GL_SMOOTH); // blends colors nicely, and smoothes out lighting // Load the texture image try { // Create a OpenGL Texture object from (URL, mipmap, file suffix) // Use URL so that can read from JAR and disk file. texture = TextureIO.newTexture( this.getClass().getResource(textureFileName), false, textureFileType); } catch (GLException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } // Use linear filter for texture if image is larger than the original texture gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Use linear filter for texture if image is smaller than the original texture gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // Texture image flips vertically. Shall use TextureCoords class to retrieve // the top, bottom, left and right coordinates, instead of using 0.0f and 1.0f. TextureCoords textureCoords = texture.getImageTexCoords(); textureTop = textureCoords.top(); textureBottom = textureCoords.bottom(); // textureLeft = textureCoords.left(); // textureRight = textureCoords.right(); // Enable the texture texture.enable(gl); // gl.glEnable(GL_TEXTURE_2D); // we want back facing polygons to be filled completely and that we want front // facing polygons to be outlined only. gl.glPolygonMode(GL_BACK, GL_FILL); // Back Face Is Filled In gl.glPolygonMode(GL_FRONT, GL_LINE); // Front Face Is Drawn With Lines for (int x = 0; x < numPoints; x++) { // Loop Through The Y Plane for (int y = 0; y < numPoints; y++) { // Apply The Wave To Our Mesh // xmax is 45. Get 9 after dividing by 5. Subtract 4.5 to centralize. points[x][y][0] = (float) x / 5.0f - 4.5f; points[x][y][1] = (float) y / 5.0f - 4.5f; // Sine wave pattern points[x][y][2] = (float) (Math.sin(Math.toRadians(x / 5.0f * 40.0f))); } } }
@Override public void init(GLAutoDrawable drawable) { GL2 gl = drawable.getGL().getGL2(); gl.glClearColor(0, 0, 0, 0); // dene a cor de fundo gl.glEnable(GL2.GL_DEPTH_TEST); // remoção de superfície oculta gl.glMatrixMode(GL2.GL_PROJECTION); // dene que a matrix é a de projeção gl.glLoadIdentity(); // carrega a matrix de identidade gl.glOrtho(-5, 5, -5, 5, -5, 5); // dene uma projeção ortográca }
public void init(GLAutoDrawable gLDrawable) { GL2 gl = gLDrawable.getGL().getGL2(); gl.glShadeModel(GLLightingFunc.GL_SMOOTH); gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f); gl.glClearDepth(1.0f); gl.glEnable(GL.GL_DEPTH_TEST); gl.glDepthFunc(GL.GL_LEQUAL); gl.glHint(GL2ES1.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST); }
/** Render this material in OpenGL2. */ public void render() { GL2 gl = GLContext.getCurrent().getGL().getGL2(); gl.glEnable(GL2.GL_COLOR_MATERIAL); gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_AMBIENT, ambient.getComponents(), 0); gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_DIFFUSE, diffuse.getComponents(), 0); gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_SPECULAR, specular.getComponents(), 0); gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_EMISSION, emission.getComponents(), 0); gl.glMateriali(GL2.GL_FRONT_AND_BACK, GL2.GL_SHININESS, shininess); }
public void init(GLAutoDrawable drawable) { GL2 gl = drawable.getGL().getGL2(); glu = new GLU(); // gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f); gl.glDepthFunc(GL.GL_LESS); gl.glEnable(GL.GL_DEPTH_TEST); gl.glShadeModel(GL2.GL_FLAT); gl.glDepthRange(0.0, 1.0); /* The default z mapping */ }
/* * Initialize material property and light source. */ public void init(GLAutoDrawable drawable) { GL2 gl = drawable.getGL().getGL2(); // float light_ambient[] = {0.0f, 0.0f, 0.0f, 1.0f}; float light_diffuse[] = {1.0f, 0.0f, 1.0f, 1.0f}; float light_specular[] = {1.0f, 0.0f, 1.0f, 1.0f}; /* light_position is NOT default value */ float light_position[] = {1.0f, 1.0f, 1.0f, 0.0f}; gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_SPECULAR, light_ambient, 0); gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_DIFFUSE, light_diffuse, 0); gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_SPECULAR, light_specular, 0); gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_POSITION, light_position, 0); gl.glEnable(GL2.GL_LIGHTING); gl.glEnable(GL2.GL_LIGHT0); gl.glDepthFunc(GL.GL_LESS); gl.glEnable(GL.GL_DEPTH_TEST); }
/** * Called back immediately after the OpenGL context is initialized. Can be used to perform * one-time initialization. Run only once. */ @Override public void init(GLAutoDrawable drawable) { GL2 gl = drawable.getGL().getGL2(); // get the OpenGL graphics context glu = new GLU(); // get GL Utilities gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // set background (clear) color gl.glClearDepth(1.0f); // set clear depth value to farthest // Do not enable depth test // gl.glEnable(GL_DEPTH_TEST); // enables depth testing // gl.glDepthFunc(GL_LEQUAL); // the type of depth test to do gl.glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // best perspective correction gl.glShadeModel(GL_SMOOTH); // blends colors nicely, and smoothes out lighting // Load the texture image try { // Use URL so that can read from JAR and disk file. BufferedImage image = ImageIO.read(this.getClass().getResource(textureFileName)); // Create a OpenGL Texture object texture = AWTTextureIO.newTexture(GLProfile.getDefault(), image, false); // Use linear filter if image is larger than the original texture gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Use linear filter if image is smaller than the original texture gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); } catch (GLException | IOException e) { e.printStackTrace(); } // Texture image flips vertically. Shall use TextureCoords class to retrieve // the top, bottom, left and right coordinates, instead of using 0.0f and 1.0f. TextureCoords textureCoords = texture.getImageTexCoords(); textureCoordTop = textureCoords.top(); textureCoordBottom = textureCoords.bottom(); textureCoordLeft = textureCoords.left(); textureCoordRight = textureCoords.right(); // Enable the texture texture.enable(gl); texture.bind(gl); // gl.glEnable(GL_TEXTURE_2D); // Enable blending gl.glEnable(GL_BLEND); gl.glBlendFunc(GL_SRC_ALPHA, GL_ONE); // Allocate the stars for (int i = 0; i < stars.length; i++) { stars[i] = new Star(); // Linearly distributed according to the star number stars[i].distance = ((float) i / numStars) * 5.0f; } }