@Override
 public void init(GLAutoDrawable drawable) {
   defAutoSwapMode = drawable.getAutoSwapBufferMode();
   swapBuffersBeforeRead =
       GLDrawableUtil.swapBuffersBeforeRead(drawable.getChosenGLCapabilities());
   drawable.setAutoSwapBufferMode(!swapBuffersBeforeRead);
 }
Esempio n. 2
0
  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);
  }
  @Override
  public void display(GLAutoDrawable glad) {
    System.out.println("display");

    GL3 gl3 = glad.getGL().getGL3();

    gl3.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
    gl3.glClear(GL3.GL_COLOR_BUFFER_BIT);

    programObject.bind(gl3);
    {
      programObject.setUniform(gl3, "offset", new float[] {0.5f, 0.5f}, 2);

      gl3.glBindBuffer(GL3.GL_ARRAY_BUFFER, vertexBufferObject[0]);

      gl3.glEnableVertexAttribArray(0);
      gl3.glEnableVertexAttribArray(1);
      {
        gl3.glVertexAttribPointer(0, 4, GL3.GL_FLOAT, false, 0, 0);
        gl3.glVertexAttribPointer(1, 4, GL3.GL_FLOAT, false, 0, 36 * 4 * 4);

        gl3.glDrawArrays(GL3.GL_TRIANGLES, 0, 36);
      }
      gl3.glDisableVertexAttribArray(0);
      gl3.glDisableVertexAttribArray(1);
    }
    programObject.unbind(gl3);

    glad.swapBuffers();
  }
Esempio n. 4
0
  /**
   * Init the rendering of this canvas. This function is called right before the first rendering
   * run. Its used to setup everything correctly.
   *
   * @param drawable the drawable object used to access the openGL functions
   */
  @Override
  public void init(final GLAutoDrawable drawable) {
    if (drawable.getContext() == null) {
      return;
    }
    displayOpenGLStatusInfo();
    // drawable.setGL(new DebugGL(drawable.getGL()));
    setupViewport(drawable);

    boolean releaseContext = false;
    if (GLContext.getCurrent() == null) {
      drawable.getContext().makeCurrent();
      releaseContext = true;
    }

    final GL gl = drawable.getGL();
    gl.glEnable(GL.GL_BLEND);
    gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
    // getContext().setSynchronized(true);
    gl.setSwapInterval(0); // disable vsync

    if (releaseContext) {
      drawable.getContext().release();
    }
  }
Esempio n. 5
0
    @Override
    public void init(GLAutoDrawable drawable) {
      super.init(drawable);
      drawable.getGL().setSwapInterval(SwapInterval);
      t0 = Platform.currentTimeMillis();

      final Window win = (Window) drawable.getUpstreamWidget();
      final MonitorDevice monitor = win.getMainMonitor();
      final float[] pixelsPerMM = new float[2];
      monitor.getPixelsPerMM(pixelsPerMM);
      final float[] dotsPerInch = new float[] {pixelsPerMM[0] * 25.4f, pixelsPerMM[1] * 25.4f};
      dpiH = dotsPerInch[1];
      System.err.println(getFontInfo());
      System.err.println(
          "fontSize "
              + fontSizeFixed
              + ", dotsPerMM "
              + pixelsPerMM[0]
              + "x"
              + pixelsPerMM[1]
              + ", dpi "
              + dotsPerInch[0]
              + "x"
              + dotsPerInch[1]
              + ", pixelSize "
              + font.getPixelSize(fontSizeFixed, dotsPerInch[1] /* dpi display */));
    }
Esempio n. 6
0
  public void init(GLAutoDrawable drawable) {
    drawable.setAutoSwapBufferMode(false);

    GL2ES2 gl = drawable.getGL().getGL2ES2();
    System.err.println("Entering initialization");
    System.err.println("GL_VERSION=" + gl.glGetString(gl.GL_VERSION));
    System.err.println("GL_EXTENSIONS:");
    System.err.println("  " + gl.glGetString(gl.GL_EXTENSIONS));

    pmvMatrix = new PMVMatrix();

    pmod.initShaderState(gl);
    st = ShaderState.getCurrent();

    // Push the 1st uniform down the path
    st.glUseProgram(gl, true);

    pmvMatrix.glMatrixMode(pmvMatrix.GL_PROJECTION);
    pmvMatrix.glLoadIdentity();
    pmvMatrix.glMatrixMode(pmvMatrix.GL_MODELVIEW);
    pmvMatrix.glLoadIdentity();

    if (!st.glUniform(gl, new GLUniformData("mgl_PMVMatrix", 4, 4, pmvMatrix.glGetPMvMatrixf()))) {
      throw new GLException("Error setting PMVMatrix in shader: " + st);
    }

    // OpenGL Render Settings
    gl.glClearColor(0, 0, 0, 1);
    gl.glEnable(GL2ES2.GL_DEPTH_TEST);

    st.glUseProgram(gl, false);

    // Let's show the completed shader state ..
    System.out.println(st);
  }
Esempio n. 7
0
  public void display(GLAutoDrawable drawable) {
    // System.err.println("SceneUIController: display");
    final int width = drawable.getWidth();
    final int height = drawable.getHeight();
    GL2ES2 gl = drawable.getGL().getGL2ES2();

    render(gl, width, height, renderModes, texSize, false);
  }
Esempio n. 8
0
  public UIShape getShape(GLAutoDrawable drawable, int x, int y) {
    final int width = drawable.getWidth();
    final int height = drawable.getHeight();
    GL2ES2 gl = drawable.getGL().getGL2ES2();

    int index = checkSelection(gl, x, y, width, height);
    if (index == -1) return null;
    return shapes.get(index);
  }
Esempio n. 9
0
  // ------------------------------------------------------------
  // GLEventListener
  public void init(GLAutoDrawable drawable) {
    if (debugging) drawable.setGL(new DebugGL(drawable.getGL()));

    try {
      // Specify new projection for this window
      init(drawable.getGL());
    } catch (GLException e) {
      e.printStackTrace();
    }
  }
Esempio n. 10
0
  @Override
  public void init(GLAutoDrawable drawable) {

    // uncomment this line to get debugging and tracing
    drawable.setGL(new DebugGL2(new TraceGL2(drawable.getGL().getGL2(), System.err)));

    // OR uncomment this line to just get debugging
    // drawable.setGL(new DebugGL2(drawable.getGL().getGL2()));
    GL2 gl = drawable.getGL().getGL2();

    gl.glClearColor(1.0f, 1.0f, 1.0f, 1f); // White Background
  }
Esempio n. 11
0
 public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
   System.err.println(
       Thread.currentThread().getName()
           + ": ** reshape: "
           + reshapeCount
           + ": "
           + width
           + "x"
           + height
           + " - "
           + drawable.getWidth()
           + "x"
           + drawable.getHeight());
   reshapeCount++;
 }
Esempio n. 12
0
  /** OpenGL drawing function */
  @Override
  public void display(GLAutoDrawable auto_drawable) {
    // get the GL context
    final GL gl = auto_drawable.getGL();
    // clear the buffers
    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
    // load the identity matrix
    gl.glLoadIdentity();

    // translations so we can see drawing
    gl.glTranslatef(0, 0, -0.7f);

    if (LoadTexturePosted == true) {
      if (LoadGuessModelPosted == null) System.err.println("ERROR: LoadGuessModelPosted is null!");
      current_Texture =
          AnimalTexture.findAnimalTexture(Animal_Tex_Array, LoadGuessModelPosted.getAnimalName());
      LoadTexturePosted = false;
    }

    // if the current texture is null, load the question texture
    if (current_Texture == null) question_Texture.bind();
    else current_Texture.bind();

    // draw the cube
    gl.glPushMatrix();
    gl.glRotatef(yrotate, 0.0f, 1.0f, 0.0f);
    drawOpenCube(gl);
    gl.glPopMatrix();

    // increase rotation
    yrotate += 0.05;
  }
  public void init(GLAutoDrawable drawable) {

    // Use debug pipeline, all OpenGL error codes will be automatically
    // converted to GLExceptions as soon as they appear
    drawable.setGL(new DebugGL2(drawable.getGL().getGL2()));

    GL2 gl = drawable.getGL().getGL2();
    System.out.println("INIT GL2 IS: " + gl.getClass().getName());

    // Enable VSync - this limits the rendering FPS to screen refresh rate
    gl.setSwapInterval(1);

    // Setup the drawing area and shading mode
    gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    gl.glShadeModel(GL2.GL_SMOOTH); // try setting this to GL_FLAT and see what happens.
  }
Esempio n. 14
0
  @Override
  public void display(GLAutoDrawable gLDrawable) {
    final GL2 gl = gLDrawable.getGL().getGL2();
    gl.glClear(GL.GL_COLOR_BUFFER_BIT);
    gl.glClear(GL.GL_DEPTH_BUFFER_BIT);
    gl.glLoadIdentity();
    gl.glTranslatef(0.0f, 0.0f, -5.0f);

    // rotate about the three axes
    gl.glRotatef(rotateT, 1.0f, 0.0f, 0.0f);
    gl.glRotatef(rotateT, 0.0f, 1.0f, 0.0f);
    gl.glRotatef(rotateT, 0.0f, 0.0f, 1.0f);

    // Draw A Quad
    gl.glBegin(GL2.GL_QUADS);
    gl.glColor3f(0.0f, 1.0f, 1.0f); // set the color of the quad
    gl.glVertex3f(-1.0f, 1.0f, 0.0f); // Top Left
    gl.glVertex3f(1.0f, 1.0f, 0.0f); // Top Right
    gl.glVertex3f(1.0f, -1.0f, 0.0f); // Bottom Right
    gl.glVertex3f(-1.0f, -1.0f, 0.0f); // Bottom Left
    // Done Drawing The Quad
    gl.glEnd();

    // increasing rotation for the next iteration
    rotateT += 0.2f;
  }
Esempio n. 15
0
  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();
  }
 @Override
 public void reshape(GLAutoDrawable drawable, int x, int y, int w, int h) {
   GL2 gl = drawable.getGL().getGL2();
   gl.glMatrixMode(GL2.GL_PROJECTION);
   gl.glLoadIdentity();
   gl.glFrustum(-1, 1, -1, 1, 1, 10);
 }
 public void display(GLAutoDrawable drawable) {
   GL gl = drawable.getGL();
   synchronized (this._camera) {
     try {
       gl.glClear(
           GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT); // Clear the buffers for new frame.
       NyARGLDrawUtil.drawBackGround(gl, this._camera.getSourceImage(), 1.0);
       this._nyar.update(this._camera);
       if (this._nyar.isExistMarker(this.ids[0])) {
         gl.glMatrixMode(GL.GL_MODELVIEW);
         gl.glPushMatrix();
         gl.glLoadMatrixd(this._nyar.getGlMarkerMatrix(this.ids[0]), 0);
         NyARGLDrawUtil.drawColorCube(gl, 40);
         gl.glPopMatrix();
       }
       if (this._nyar.isExistMarker(this.ids[1])) {
         gl.glMatrixMode(GL.GL_MODELVIEW);
         gl.glPushMatrix();
         gl.glLoadMatrixd(this._nyar.getGlMarkerMatrix(this.ids[1]), 0);
         NyARGLDrawUtil.drawColorCube(gl, 40);
         gl.glPopMatrix();
       }
       Thread.sleep(1);
     } catch (Exception e) {
       e.printStackTrace();
     }
   }
 }
  @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);
  }
Esempio n. 19
0
  /** Called back by the animator to perform rendering. */
  @Override
  public void display(GLAutoDrawable drawable) {
    GL2 gl = drawable.getGL().getGL2(); // get the OpenGL 2 graphics context
    gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // clear color and depth buffers
    gl.glLoadIdentity(); // reset the model-view matrix

    gl.glTranslatef(0.0f, 0.0f, -12.0f);
    gl.glRotatef(rotateAnleX, 1.0f, 0.0f, 0.0f);
    gl.glRotatef(rotateAnleY, 0.0f, 1.0f, 0.0f);
    gl.glRotatef(rotateAngleZ, 0.0f, 0.0f, 1.0f);

    // need to flip the image
    float textureHeight = textureTop - textureBottom;

    float x1, y1, x2, y2; // used to break the flag into tiny quads

    gl.glBegin(GL_QUADS);
    for (int x = 0; x < numPoints - 1; x++) {
      for (int y = 0; y < numPoints - 1; y++) {
        x1 = (float) x / 44.0f;
        y1 = (float) y / 44.0f;
        x2 = (float) (x + 1) / 44.0f;
        y2 = (float) (y + 1) / 44.0f;

        // Texture need to flip vertically
        gl.glTexCoord2f(x1, y1 * textureHeight + textureBottom);
        gl.glVertex3f(points[x][y][0], points[x][y][1], points[x][y][2]);

        gl.glTexCoord2f(x1, y2 * textureHeight + textureBottom);
        gl.glVertex3f(points[x][y + 1][0], points[x][y + 1][1], points[x][y + 1][2]);

        gl.glTexCoord2f(x2, y2 * textureHeight + textureBottom);
        gl.glVertex3f(points[x + 1][y + 1][0], points[x + 1][y + 1][1], points[x + 1][y + 1][2]);

        gl.glTexCoord2f(x2, y1 * textureHeight + textureBottom);
        gl.glVertex3f(points[x + 1][y][0], points[x + 1][y][1], points[x + 1][y][2]);
      }
    }
    gl.glEnd();

    if (wiggleCount == 2) { // Used To Slow Down The Wave (Every 2nd Frame Only)
      for (int y = 0; y < 45; y++) {
        float tempHold = points[0][y][2]; // Store current value One Left Side Of
        // Wave
        for (int x = 0; x < 44; x++) {
          // Current Wave Value Equals Value To The Right
          points[x][y][2] = points[x + 1][y][2];
        }
        points[44][y][2] = tempHold; // Last Value Becomes The Far Left Stored
        // Value
      }
      wiggleCount = 0; // Set Counter Back To Zero
    }
    wiggleCount++;

    // update the rotational position after each refresh
    rotateAnleX += roateSpeedX;
    rotateAnleY += rotateSpeedY;
    rotateAngleZ += rotateSpeedZ;
  }
Esempio n. 20
0
  /**
   * Main drawing function. Inside this function the main part of the drawing is done.
   *
   * @param drawable the drawable object that is used to trigger the drawing actions
   */
  @Override
  public void display(final GLAutoDrawable drawable) {
    final GL gl = drawable.getGL();
    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);

    manager.draw();
  }
Esempio n. 21
0
  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();
  }
Esempio n. 22
0
  public void display(GLAutoDrawable drawable) {
    GL2 gl = drawable.getGL().getGL2();
    //
    gl.glClear(GL.GL_COLOR_BUFFER_BIT);

    if (derefMethod == DRAWARRAY) {
      gl.glDrawArrays(GL2.GL_TRIANGLES, 0, 6);
    } else if (derefMethod == ARRAYELEMENT) {
      gl.glBegin(GL2.GL_TRIANGLES);
      gl.glArrayElement(2);
      gl.glArrayElement(3);
      gl.glArrayElement(5);
      gl.glEnd();
    } else if (derefMethod == DRAWELEMENTS) {
      int indices[] = new int[] {0, 1, 3, 4};
      if (indicesBuf == null) {
        indicesBuf = GLBuffers.newDirectIntBuffer(indices.length);
        indicesBuf.put(indices);
      }
      indicesBuf.rewind();
      gl.glDrawElements(GL2.GL_POLYGON, 4, GL2.GL_UNSIGNED_INT, indicesBuf);
    }
    gl.glFlush();

    // gl calls from C example's mouse routine are moved here
    if (setupMethod == INTERLEAVED) setupInterleave(gl);
    else if (setupMethod == POINTER) setupPointers(gl);
  }
Esempio n. 23
0
  public final void display(final GLAutoDrawable drawable) {
    final GL gl = drawable.getGL();

    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
    gl.glMatrixMode(GL.GL_MODELVIEW);
    gl.glLoadIdentity();

    this.applyCameraAdjustment(gl);

    long t = System.currentTimeMillis();
    long dt = t - tprec;
    tprec = t;
    mdx.update(dt);

    renderReference(gl, ORIGIN, X_AXIS.clone(), Y_AXIS.clone(), Z_AXIS.clone());
    renderReferences(gl);

    gl.glColor3f(1.0f, 1.0f, 1.0f);

    int[] temp = selector.getGeoOn();
    if (temp != null) {
      for (int i = 0; i < temp.length; ++i) this.renderNonBlending(mdx.getGeoset(temp[i]), gl);
      for (int i = 0; i < temp.length; ++i) this.renderBlending(mdx.getGeoset(temp[i]), gl);
    }
  }
Esempio n. 24
0
  public void display(GLAutoDrawable drawable) {
    GL2 gl = drawable.getGL().getGL2();
    //
    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
    gl.glPushMatrix();
    gl.glRotatef(20.0f, 1.0f, 0.0f, 0.0f);

    gl.glPushMatrix();
    gl.glTranslatef(-0.75f, 0.5f, 0.0f);
    gl.glRotatef(90.0f, 1.0f, 0.0f, 0.0f);

    glut.glutSolidTorus(0.275f, 0.85f, 20, 20);
    gl.glPopMatrix();

    gl.glPushMatrix();
    gl.glTranslatef(-0.75f, -0.5f, 0.0f);
    gl.glRotatef(270.0f, 1.0f, 0.0f, 0.0f);
    glut.glutSolidCone(1.0f, 2.0f, 20, 20);
    gl.glPopMatrix();

    gl.glPushMatrix();
    gl.glTranslatef(0.75f, 0.0f, -1.0f);
    glut.glutSolidSphere(1.0f, 20, 20);
    gl.glPopMatrix();

    gl.glPopMatrix();
    gl.glFlush();
  }
Esempio n. 25
0
  @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 glad) {
    System.out.println("init");

    canvas.setAutoSwapBufferMode(false);

    GL3 gl3 = glad.getGL().getGL3();

    buildShaders(gl3);

    programObject.bind(gl3);
    {
      programObject.setUniform(gl3, "frustumScale", new float[] {1.0f}, 1);
      programObject.setUniform(gl3, "zNear", new float[] {1.0f}, 1);
      programObject.setUniform(gl3, "zFar", new float[] {3.0f}, 1);
    }
    programObject.unbind(gl3);

    initializeVertexBuffer(gl3);

    gl3.glGenVertexArrays(1, IntBuffer.wrap(vertexArrayObject));
    gl3.glBindVertexArray(vertexArrayObject[0]);

    gl3.glEnable(GL3.GL_CULL_FACE);
    gl3.glCullFace(GL3.GL_BACK);
    gl3.glFrontFace(GL3.GL_CW);
  }
Esempio n. 27
0
  /**
   * Renders the skybox using VBO
   *
   * @param drawable current rendering context
   */
  public void display(GLAutoDrawable drawable) {
    GL gl = drawable.getGL();

    // Enable arrays
    gl.glEnableClientState(GL.GL_VERTEX_ARRAY);
    gl.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY);

    if (nVertices == 0) {
      createVBO(gl);
    }

    // gl.glDisable(GL.GL_CULL_FACE);
    gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_REPLACE);
    gl.glEnable(GL.GL_TEXTURE_2D);
    texture.load(gl);

    // Vertex coordinates
    gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, VBOIds[0]);
    gl.glVertexPointer(3, GL.GL_FLOAT, 0, 0);

    gl.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, VBOIds[1]);
    gl.glTexCoordPointer(2, GL.GL_FLOAT, 0, 0);

    // Render
    // Draw All Of The Triangles At Once
    gl.glDrawArrays(GL.GL_TRIANGLES, 0, nVertices);

    // Disable Vertex Arrays
    gl.glDisableClientState(GL.GL_VERTEX_ARRAY);
    gl.glDisableClientState(GL.GL_TEXTURE_COORD_ARRAY);

    gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_MODULATE);
    // gl.glEnable(GL.GL_CULL_FACE);
  }
Esempio n. 28
0
  public void display(GLAutoDrawable drawable) {
    GL2 gl = drawable.getGL().getGL2();

    // need a valid GL context for this ..

    /** OpenGL .. texture.updateSubImage(textureData, 0, 20, 20, 20, 20, 100, 100); */

    // Now draw one quad with the texture
    if (null != texture) {
      texture.enable();
      texture.bind();
      gl.glTexEnvi(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, GL2.GL_REPLACE);
      TextureCoords coords = texture.getImageTexCoords();
      gl.glBegin(GL2.GL_QUADS);
      gl.glTexCoord2f(coords.left(), coords.bottom());
      gl.glVertex3f(0, 0, 0);
      gl.glTexCoord2f(coords.right(), coords.bottom());
      gl.glVertex3f(1, 0, 0);
      gl.glTexCoord2f(coords.right(), coords.top());
      gl.glVertex3f(1, 1, 0);
      gl.glTexCoord2f(coords.left(), coords.top());
      gl.glVertex3f(0, 1, 0);
      gl.glEnd();
      texture.disable();
    }
  }
Esempio n. 29
0
  public final void init(final GLAutoDrawable drawable) {
    Debug.print();
    final GL gl = drawable.getGL();
    gl.glEnable(GL.GL_DEPTH_TEST);

    TextureManager.clear();
  }
Esempio n. 30
0
 public void init(GLAutoDrawable drawable) {
   GL gl = drawable.getGL();
   System.err.println("INIT GL IS: " + gl.getClass().getName());
   gl.setSwapInterval(1);
   gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
   gl.glShadeModel(GL.GL_SMOOTH); // try setting this to GL_FLAT and see what happens.
 }