protected void drawToolTip(
      DrawContext dc,
      java.awt.Rectangle viewport,
      String text,
      int x,
      int y,
      ToolTipAttributes attributes) {
    java.awt.geom.Rectangle2D textBounds = this.computeTextBounds(dc, text, attributes.getFont());
    java.awt.geom.Rectangle2D bgBounds =
        this.computeBackgroundBounds(
            dc, textBounds.getWidth(), textBounds.getHeight(), attributes.getInsets());

    java.awt.Point screenPoint = this.adjustDrawPointToViewport(x, y, bgBounds, viewport);
    java.awt.geom.Point2D textTranslation =
        this.computeTextTranslation(dc, textBounds, attributes.getInsets());

    GL2 gl = dc.getGL();
    OGLStackHandler stackHandler = new OGLStackHandler();

    stackHandler.pushModelview(gl);
    try {
      gl.glTranslated(
          screenPoint.getX() + bgBounds.getX(), screenPoint.getY() + bgBounds.getY(), 0);
      this.drawToolTipInterior(dc, bgBounds.getWidth(), bgBounds.getHeight(), attributes);
      this.drawToolTipOutline(dc, bgBounds.getWidth(), bgBounds.getHeight(), attributes);

      gl.glTranslated(textTranslation.getX(), textTranslation.getY(), 0);
      this.drawToolTipText(dc, text, 0, 0, attributes);
    } finally {
      stackHandler.pop(gl);
    }
  }
  void drawPart(Part part, double x, double y, double z, double r) {
    gl.glPushMatrix();
    gl.glTranslated(x, y, z);

    // TODO
    gl.glTranslated(0, part.h - part.w / 2, 0);
    gl.glRotated(r, 1, 0, 0);
    gl.glTranslated(0, part.w / 2 - part.h, 0);

    drawCuboid(part);
    gl.glPopMatrix();
  }
  /**
   * Draw the object and all of its descendants recursively.
   *
   * <p>TODO: Complete this method
   *
   * @param gl
   */
  public void draw(GL2 gl) {

    // don't draw if it is not showing
    if (!amShowing) {
      return;
    }

    // TODO: draw the object and all its children recursively
    // setting the model transform appropriately

    // Call drawSelf() to draw the object itself
    gl.glMatrixMode(GL2.GL_MODELVIEW);
    {
      gl.glPushMatrix();
      {
        gl.glTranslated(myTranslation[0], myTranslation[1], 0);
        gl.glScaled(myScale, myScale, 1);
        gl.glRotated(myRotation, 0, 0, 1);
        drawSelf(gl);
        for (GameObject child : myChildren) {
          child.draw(gl);
        }
      }
      gl.glPopMatrix();
    }
  }
  @Override
  public void draw(GL2 gl, Object obj) {
    if (!(Force.class.isAssignableFrom(obj.getClass()))) return;

    Force force = (Force) obj;

    gl.glLineWidth(2.5f);
    gl.glColor3f(1.0f, 0f, 0f);
    gl.glBegin(GL.GL_LINES);
    gl.glVertex3d(
        force.getPointApplication().getX(),
        force.getPointApplication().getY(),
        force.getPointApplication().getZ());

    Vector3D finalPoint = force.getPointApplication().add(force.getForce());
    gl.glVertex3d(finalPoint.getX(), finalPoint.getY(), finalPoint.getZ());
    gl.glEnd();

    gl.glTranslated(
        force.getPointApplication().getX(),
        force.getPointApplication().getY(),
        force.getPointApplication().getZ());
    gl.glColor3f(1.0f, 0.0f, 0.0f);
    GLU glu = new GLU();
    GLUquadric q = glu.gluNewQuadric();
    glu.gluQuadricDrawStyle(q, GLU.GLU_FILL);
    glu.gluSphere(q, Force.originRadius, 5, 5);
    glu.gluDeleteQuadric(q);
  }
Exemple #5
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
  }
Exemple #6
0
  private void buildFont(GL2 gl) { // Build Our Font Display List

    base = gl.glGenLists(256); // Creating 256 Display Lists

    for (int loop1 = 0; loop1 < 256; loop1++) { // Loop Through All 256
      // Lists

      float cx = (float) (loop1 % 16) / 16.0f; // X Position Of Current
      // Character
      float cy = (float) (loop1 / 16) / 16.0f; // Y Position Of Current
      // Character

      gl.glNewList(base + loop1, GL2.GL_COMPILE); // Start Building A List
      gl.glBegin(GL2.GL_QUADS); // Use A Quad For Each Character
      gl.glTexCoord2f(cx, 1.0f - cy - 0.0625f); // Texture Coord (Bottom
      // Left)
      gl.glVertex2d(0, 16); // Vertex Coord (Bottom Left)
      gl.glTexCoord2f(cx + 0.0625f, 1.0f - cy - 0.0625f); // Texture Coord
      // (Bottom
      // Right)
      gl.glVertex2i(16, 16); // Vertex Coord (Bottom Right)
      gl.glTexCoord2f(cx + 0.0625f, 1.0f - cy - 0.001f); // Texture Coord
      // (Top Right)
      gl.glVertex2i(16, 0); // Vertex Coord (Top Right)
      gl.glTexCoord2f(cx, 1.0f - cy - 0.001f); // Texture Coord (Top Left)
      gl.glVertex2i(0, 0); // Vertex Coord (Top Left)
      gl.glEnd(); // Done Building Our Quad (Character)
      gl.glTranslated(14, 0, 0); // Move To The Right Of The Character
      gl.glEndList(); // Done Building The Display List
    } // Loop Until All 256 Are Built
  }
  public void display(GLAutoDrawable drawable) {
    GL2 gl = drawable.getGL().getGL2();

    gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL2.GL_AMBIENT_AND_DIFFUSE, color, 0);
    gl.glRotated(rotateX.getValue(), 1, 0, 0);
    gl.glRotated(rotateY.getValue(), 0, 1, 0);
    gl.glRotated(rotateZ.getValue(), 0, 0, 1);
    gl.glPushMatrix();
    gl.glTranslated(translateX.getValue(), translateY.getValue(), translateZ.getValue());
    gl.glPushMatrix();
    gl.glRotated(90, 1, 0, 0);
    gl.glTranslated(0, 0, -height / 2);
    glut.glutSolidCylinder(radius, height, 32, 2);
    gl.glPopMatrix();
    super.display(drawable);
    gl.glPopMatrix();
  }
Exemple #8
0
 public void render(GLAutoDrawable drawable) {
   GL2 gl = drawable.getGL().getGL2();
   gl.glPushMatrix();
   gl.glTranslated(
       body.getPosition().get0(), body.getPosition().get1(), body.getPosition().get2());
   GLUquadric bulletGeom = glu.gluNewQuadric();
   glu.gluQuadricDrawStyle(bulletGeom, GLU.GLU_FILL);
   glu.gluQuadricNormals(bulletGeom, GLU.GLU_SMOOTH);
   glu.gluDisk(bulletGeom, 0.3, 0.4, 5, 5);
   gl.glPopMatrix();
 }
 @Override
 public void draw(int depth) {
   // only render the sphere if this node is at the given depth
   if (((depth < 0) && (Math.abs(depth) >= this.depth)) || depth == this.depth) {
     GL2 gl = GLContext.getCurrent().getGL().getGL2();
     gl.glPushMatrix();
     gl.glTranslated(center.x, center.y, center.z);
     JDraw3D.jDrawSphere(radius, 10, 10);
     gl.glPopMatrix();
   }
 }
Exemple #10
0
  protected void applyBackground(
      DrawContext dc,
      WWIcon icon,
      Vec4 screenPoint,
      double width,
      double height,
      double pedestalSpacing,
      double pedestalScale) {
    GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.

    double backgroundScale;
    backgroundScale = icon.getBackgroundScale();

    if (icon.getBackgroundTexture() != null) {
      if (icon.getBackgroundTexture().bind(dc)) {
        TextureCoords texCoords = icon.getBackgroundTexture().getTexCoords();
        gl.glPushMatrix();
        gl.glLoadIdentity();
        double bgwidth = backgroundScale * width;
        double bgheight = backgroundScale * height;
        // Offset the background for the highlighted scale.
        // if (icon.isHighlighted())
        // {
        //    gl.glTranslated(0d, height * (icon.getHighlightScale() - 1) / 2, 0d);
        // }
        // Offset the background for the pedestal height.
        gl.glTranslated(0d, (pedestalScale * height) + pedestalSpacing, 0d);
        // Place the background centered behind the icon.
        gl.glTranslated(screenPoint.x - bgwidth / 2, screenPoint.y - (bgheight - height) / 2, 0d);
        // Scale to the background image dimension.
        gl.glScaled(bgwidth, bgheight, 1d);
        dc.drawUnitQuad(texCoords);
        gl.glPopMatrix();
      }
    }
  }
  public void draw(GL2 gl, GLU glu) {
    gl.glColor3f(1f, 0f, .25f);

    // Lamp Stem, cylindrical, a little smaller at the top.
    gl.glPushMatrix();
    gl.glRotatef(-90f, 1f, 0f, 0f); // stand upright (Y)
    glu.gluCylinder(quadric, 1., 1, 3., 10, 1);
    gl.glPopMatrix();

    // Table Top
    gl.glPushMatrix();
    gl.glTranslated(0, 3, 0);
    gl.glRotatef(-90f, 100f, 0f, 0f); // stand upright (Y)
    glu.gluDisk(quadric, 0, 4., 15, 5); // also to be flipped
    gl.glPopMatrix();
  }
  @Override
  public void display(GLAutoDrawable drawable) {
    GL2 gl = drawable.getGL().getGL2();

    gl.glMatrixMode(GL2.GL_MODELVIEW);
    gl.glLoadIdentity();

    // to position the camera.

    gl.glTranslated(0, 0, -1);

    // Forgetting to clear the depth buffer can cause problems
    // such as empty black screens.
    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);
    float matAmbAndDifR[] = {0.9f, 0.0f, 0.0f, 0.75f};
    float matAmbAndDifG[] = {0.0f, 0.5f, 0.0f, 1.0f};

    gl.glBegin(GL2.GL_TRIANGLES);
    {

      // One in drawn first and in front has alpha
      // gl.glColor4f(1f,0f,0f,1f);
      // CCW ordering of vertices
      double p0[] = {1, 0, -1};
      double p1[] = {0, 1, -1};
      double p2[] = {-1, 0, -1};

      gl.glMaterialfv(GL2.GL_FRONT, GL2.GL_AMBIENT_AND_DIFFUSE, matAmbAndDifG, 0);

      // gl.glColor4f(0,1,0,1f);
      gl.glVertex3d(2, 0, -2);
      gl.glVertex3d(1, 1, -2);
      gl.glVertex3d(0, 0, -2);

      gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_AMBIENT_AND_DIFFUSE, matAmbAndDifR, 0);
      gl.glVertex3dv(p0, 0);
      gl.glVertex3dv(p1, 0);
      gl.glVertex3dv(p2, 0);
    }
    gl.glEnd();

    gl.glPolygonMode(GL2.GL_FRONT_AND_BACK, GL2.GL_FILL);
  }
  @Override
  public void display(GLAutoDrawable drawable) {
    GL2 gl = drawable.getGL().getGL2();

    gl.glMatrixMode(GL2.GL_MODELVIEW);
    gl.glLoadIdentity();

    // Move camera back a little
    gl.glTranslated(0, 0, -1);

    // Forgetting to clear the depth buffer can cause problems
    // such as empty black screens.
    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);

    gl.glBegin(GL2.GL_TRIANGLES);
    {

      // Need to draw transparent one last
      gl.glColor4f(1f, 0f, 0f, 0.75f); // try with 0.25
      // CCW ordering of vertices
      double p0[] = {1, 0, -1};
      double p1[] = {0, 1, -1};
      double p2[] = {-1, 0, -1};

      // Can pass in an array and an offset into the array
      gl.glVertex3dv(p0, 0);
      gl.glVertex3dv(p1, 0);
      gl.glVertex3dv(p2, 0);

      // Opaque one (at back) must be drawn before
      // transparent one in front
      gl.glColor4f(0, 1, 0, 1f);
      gl.glVertex3d(2, 0, -2);
      gl.glVertex3d(1, 1, -2);
      gl.glVertex3d(0, 0, -2);
    }
    gl.glEnd();
  }
Exemple #14
0
 /**
  * Draws this robot on the screen.
  *
  * @param gl The instance of GL2 responsible for drawing the robot on the screen.
  * @param glut An instance of GLUT to optionally aid in drawing the robot body.
  * @param stickFigure If true, the robot must draw itself as a stick figure rather than a solid
  *     body.
  * @param tAnim Time since the start of the animation in seconds.
  * @param lighting The Lighting instance responsible for calculating the lighting in this scene.
  *     Can be used to set the color of bodies before drawing them.
  */
 public void draw(GL2 gl, GLUT glut, boolean stickFigure, float tAnim, Lighting lighting) {
   lighting.setMaterial(gl, getMaterial());
   gl.glPushMatrix();
   {
     gl.glTranslated(position.x(), position.y(), position.z());
     final double rotationDotY =
         direction.dot(Vector.Y) / (direction.length() * Vector.Y.length());
     final double rotationDotX =
         direction.dot(Vector.X) / (direction.length() * Vector.X.length());
     final double rotationAngle = Math.toDegrees(Math.acos(rotationDotY));
     gl.glRotated(
         (rotationDotX > 0d) ? (-rotationAngle) : (rotationAngle),
         Vector.Z.x(),
         Vector.Z.y(),
         Vector.Z.z());
     final double elevationDot =
         direction.dot(Vector.Z) / (direction.length() * Vector.Z.length());
     final double elevationAngle = Math.toDegrees(Math.asin(elevationDot));
     gl.glRotated(elevationAngle, Vector.X.x(), Vector.X.y(), Vector.X.z());
     robotBody.draw(gl, glut, stickFigure, tAnim);
   }
   gl.glPopMatrix();
 }
  public void render(GL2 gl2) {
    int i;

    boolean draw_finger_star = false;
    boolean draw_base_star = false;
    boolean draw_shoulder_to_elbow = false;
    boolean draw_shoulder_star = false;
    boolean draw_elbow_star = false;
    boolean draw_wrist_star = false;
    boolean draw_stl = true;

    // RebuildShoulders(motion_now);

    gl2.glPushMatrix();
    gl2.glTranslated(position.x, position.y, position.z);

    if (draw_stl) {
      // base
      gl2.glPushMatrix();
      gl2.glColor3f(0, 0, 1);
      gl2.glTranslatef(0, 0, BASE_TO_SHOULDER_Z + 0.6f);
      gl2.glRotatef(90, 0, 0, 1);
      gl2.glRotatef(90, 1, 0, 0);
      modelBase.render(gl2);
      gl2.glPopMatrix();

      // arms
      for (i = 0; i < 3; ++i) {
        gl2.glColor3f(1, 0, 1);
        gl2.glPushMatrix();
        gl2.glTranslatef(
            motion_now.arms[i * 2 + 0].shoulder.x,
            motion_now.arms[i * 2 + 0].shoulder.y,
            motion_now.arms[i * 2 + 0].shoulder.z);
        gl2.glRotatef(120.0f * i, 0, 0, 1);
        gl2.glRotatef(90, 0, 1, 0);
        gl2.glRotatef(180 - motion_now.arms[i * 2 + 0].angle, 0, 0, 1);
        modelArm.render(gl2);
        gl2.glPopMatrix();

        gl2.glColor3f(1, 1, 0);
        gl2.glPushMatrix();
        gl2.glTranslatef(
            motion_now.arms[i * 2 + 1].shoulder.x,
            motion_now.arms[i * 2 + 1].shoulder.y,
            motion_now.arms[i * 2 + 1].shoulder.z);
        gl2.glRotatef(120.0f * i, 0, 0, 1);
        gl2.glRotatef(90, 0, 1, 0);
        gl2.glRotatef(+motion_now.arms[i * 2 + 1].angle, 0, 0, 1);
        modelArm.render(gl2);
        gl2.glPopMatrix();
      }
      // top
      gl2.glPushMatrix();
      gl2.glColor3f(0, 1, 0);
      gl2.glTranslatef(motion_now.finger_tip.x, motion_now.finger_tip.y, motion_now.finger_tip.z);
      gl2.glRotatef(motion_now.iku, 1, 0, 0);
      gl2.glRotatef(motion_now.ikv, 0, 1, 0);
      gl2.glRotatef(motion_now.ikw, 0, 0, 1);
      gl2.glRotatef(90, 0, 0, 1);
      gl2.glRotatef(180, 1, 0, 0);
      modelTop.render(gl2);
      gl2.glPopMatrix();
    }

    // draw the forearms

    Cylinder tube = new Cylinder();
    gl2.glColor3f(0.8f, 0.8f, 0.8f);
    tube.setRadius(0.15f);
    for (i = 0; i < 6; ++i) {
      // gl2.glBegin(GL2.GL_LINES);
      // gl2.glColor3f(1,0,0);
      // gl2.glVertex3f(motion_now.arms[i].wrist.x,motion_now.arms[i].wrist.y,motion_now.arms[i].wrist.z);
      // gl2.glColor3f(0,1,0);
      // gl2.glVertex3f(motion_now.arms[i].elbow.x,motion_now.arms[i].elbow.y,motion_now.arms[i].elbow.z);
      // gl2.glEnd();
      tube.SetP1(motion_now.arms[i].wrist);
      tube.SetP2(motion_now.arms[i].elbow);
      PrimitiveSolids.drawCylinder(gl2, tube);
    }

    gl2.glDisable(GL2.GL_LIGHTING);
    // debug info
    gl2.glPushMatrix();
    for (i = 0; i < 6; ++i) {
      gl2.glColor3f(1, 1, 1);
      if (draw_shoulder_star) PrimitiveSolids.drawStar(gl2, motion_now.arms[i].shoulder, 5);
      if (draw_elbow_star) PrimitiveSolids.drawStar(gl2, motion_now.arms[i].elbow, 3);
      if (draw_wrist_star) PrimitiveSolids.drawStar(gl2, motion_now.arms[i].wrist, 1);

      if (draw_shoulder_to_elbow) {
        gl2.glBegin(GL2.GL_LINES);
        gl2.glColor3f(0, 1, 0);
        gl2.glVertex3f(
            motion_now.arms[i].elbow.x, motion_now.arms[i].elbow.y, motion_now.arms[i].elbow.z);
        gl2.glColor3f(0, 0, 1);
        gl2.glVertex3f(
            motion_now.arms[i].shoulder.x,
            motion_now.arms[i].shoulder.y,
            motion_now.arms[i].shoulder.z);
        gl2.glEnd();
      }
    }
    gl2.glPopMatrix();

    if (draw_finger_star) {
      // draw finger orientation
      float s = 2;
      gl2.glBegin(GL2.GL_LINES);
      gl2.glColor3f(1, 1, 1);
      gl2.glVertex3f(motion_now.finger_tip.x, motion_now.finger_tip.y, motion_now.finger_tip.z);
      gl2.glVertex3f(
          motion_now.finger_tip.x + motion_now.finger_forward.x * s,
          motion_now.finger_tip.y + motion_now.finger_forward.y * s,
          motion_now.finger_tip.z + motion_now.finger_forward.z * s);
      gl2.glVertex3f(motion_now.finger_tip.x, motion_now.finger_tip.y, motion_now.finger_tip.z);
      gl2.glVertex3f(
          motion_now.finger_tip.x + motion_now.finger_up.x * s,
          motion_now.finger_tip.y + motion_now.finger_up.y * s,
          motion_now.finger_tip.z + motion_now.finger_up.z * s);
      gl2.glVertex3f(motion_now.finger_tip.x, motion_now.finger_tip.y, motion_now.finger_tip.z);
      gl2.glVertex3f(
          motion_now.finger_tip.x + motion_now.finger_left.x * s,
          motion_now.finger_tip.y + motion_now.finger_left.y * s,
          motion_now.finger_tip.z + motion_now.finger_left.z * s);

      gl2.glEnd();
    }

    if (draw_base_star) {
      // draw finger orientation
      float s = 2;
      gl2.glDisable(GL2.GL_DEPTH_TEST);
      gl2.glBegin(GL2.GL_LINES);
      gl2.glColor3f(1, 0, 0);
      gl2.glVertex3f(motion_now.base.x, motion_now.base.y, motion_now.base.z);
      gl2.glVertex3f(
          motion_now.base.x + motion_now.base_forward.x * s,
          motion_now.base.y + motion_now.base_forward.y * s,
          motion_now.base.z + motion_now.base_forward.z * s);
      gl2.glColor3f(0, 1, 0);
      gl2.glVertex3f(motion_now.base.x, motion_now.base.y, motion_now.base.z);
      gl2.glVertex3f(
          motion_now.base.x + motion_now.base_up.x * s,
          motion_now.base.y + motion_now.base_up.y * s,
          motion_now.base.z + motion_now.base_up.z * s);
      gl2.glColor3f(0, 0, 1);
      gl2.glVertex3f(motion_now.base.x, motion_now.base.y, motion_now.base.z);
      gl2.glVertex3f(
          motion_now.base.x + motion_now.finger_left.x * s,
          motion_now.base.y + motion_now.finger_left.y * s,
          motion_now.base.z + motion_now.finger_left.z * s);

      gl2.glEnd();
      gl2.glEnable(GL2.GL_DEPTH_TEST);
    }

    gl2.glEnable(GL2.GL_LIGHTING);

    gl2.glPopMatrix();
  }
  public void draw(GL2 gl, Camera camera, Perspective3D perspective3d) {
    Photo photo = this.photo;

    gl.glDisable(GL2.GL_DEPTH_TEST);
    gl.glColor4f(
        (float) 255 / 255, (float) 255 / 255, (float) 255 / 255, (float) photo.getTransparent());

    // Enable Alpha Blending (disable alpha testing)
    gl.glBlendFunc(GL2.GL_SRC_ALPHA, GL2.GL_ONE_MINUS_SRC_ALPHA);
    gl.glEnable(GL2.GL_BLEND);

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

    // XXX
    String textureName = photo.getPath();

    TextureCoords tc = new TextureCoords(0, 0, 1, 1);
    if (textureName != null) {
      Texture texture = this.textureCacheService.getTexture(gl, textureName);

      //            // switch to texture mode and push a new matrix on the stack
      //            gl.glMatrixMode(GL2.GL_TEXTURE);
      //            gl.glPushMatrix();
      //
      //            // check to see if the texture needs flipping
      //            if (texture.getMustFlipVertically()) {
      //                gl.glScaled(1, -1, 1);
      //                gl.glTranslated(0, -1, 0);
      //            }
      //
      //            // switch to modelview matrix and push a new matrix on the stack
      //            gl.glMatrixMode(GL2.GL_MODELVIEW);
      //            gl.glPushMatrix();
      //
      //            // This is required to repeat textures
      //            gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2.GL_TEXTURE_WRAP_S, GL2.GL_REPEAT);
      //            gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2.GL_TEXTURE_WRAP_T, GL2.GL_REPEAT);

      // enable, bind
      texture.enable(gl);
      texture.bind(gl);

      tc = texture.getImageTexCoords();
    }

    gl.glBegin(GL2.GL_POLYGON);
    //        gl.glColor3f((float)123/256, (float)111/256, (float)100/255);
    //        gl.glColor3f((float) 255/255, (float)255/255, (float)255/255);

    LatLon ll = new LatLon(photo.getLat(), photo.getLon());

    Projection proj = Main.getProjection();

    EastNorth eastNorth = proj.latlon2eastNorth(ll);

    double x = perspective3d.calcX(eastNorth.east());
    double y = photo.getHeight();
    double z = -perspective3d.calcY(eastNorth.north());

    Vector3d angle = photo.getRotate();

    double distance = 500d;

    double width = distance * Math.sin(photo.getAngleWitht() / 2d);
    double height = distance * Math.sin(photo.getAngleHeigth() / 2d);

    Vector3d p1 = new Vector3d(distance, -height, -width);
    Vector3d p2 = new Vector3d(distance, -height, width);
    Vector3d p3 = new Vector3d(distance, height, width);
    Vector3d p4 = new Vector3d(distance, height, -width);

    p1 = transform(angle, p1);
    p2 = transform(angle, p2);
    p3 = transform(angle, p3);
    p4 = transform(angle, p4);

    Point3d c = camera.getPoint();

    // gl.glColor4f((float) 255/255, (float)255/255, (float)255/255, (float) 128/255);
    gl.glTexEnvi(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, GL2.GL_BLEND);

    gl.glTexCoord2d(tc.left(), tc.bottom());
    gl.glVertex3d(p1.x + x, p1.y + y, p1.z + z);
    gl.glTexCoord2d(tc.right(), tc.bottom());
    gl.glVertex3d(p2.x + x, p2.y + y, p2.z + z);
    gl.glTexCoord2d(tc.right(), tc.top());
    gl.glVertex3d(p3.x + x, p3.y + y, p3.z + z);
    gl.glTexCoord2d(tc.left(), tc.top());
    gl.glVertex3d(p4.x + x, p4.y + y, p4.z + z);

    gl.glEnd();

    gl.glColor3f((float) 0 / 255, (float) 0 / 255, (float) 255 / 255);

    gl.glPushMatrix();

    gl.glTranslated(x, 0.1, z);

    gl.glTexEnvi(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, GL2.GL_MODULATE);

    DrawUtil.drawDotY(gl, 0.5, 12);
    gl.glPopMatrix();

    if (textureName != null) {
      Texture texture = this.textureCacheService.getTexture(gl, textureName);

      Texture t = this.textureCacheService.getTexture(gl, textureName);
      // this.textures.get(mesh.materialID);// .get(mesh.materialID);
      if (t != null) {
        t.disable(gl);
      }

      gl.glMatrixMode(GL2.GL_TEXTURE);
      gl.glPopMatrix();

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

    gl.glDisable(GL2.GL_TEXTURE_2D);

    gl.glColor4f((float) 255 / 255, (float) 255 / 255, (float) 255 / 255, (float) 255 / 255);

    gl.glDisable(GL2.GL_BLEND);
    gl.glEnable(GL2.GL_DEPTH_TEST);
  }
Exemple #17
0
  protected Vec4 drawIcon(DrawContext dc, OrderedIcon uIcon) {
    if (uIcon.point == null) {
      String msg = Logging.getMessage("nullValue.PointIsNull");
      Logging.logger().severe(msg);

      // Record feedback data for this WWIcon if feedback is enabled.
      if (uIcon.icon != null) this.recordFeedback(dc, uIcon.icon, null, null);

      return null;
    }

    WWIcon icon = uIcon.icon;
    if (dc.getView().getFrustumInModelCoordinates().getNear().distanceTo(uIcon.point) < 0) {
      // Record feedback data for this WWIcon if feedback is enabled.
      this.recordFeedback(dc, icon, uIcon.point, null);

      return null;
    }

    final Vec4 screenPoint = dc.getView().project(uIcon.point);
    if (screenPoint == null) {
      // Record feedback data for this WWIcon if feedback is enabled.
      this.recordFeedback(dc, icon, uIcon.point, null);

      return null;
    }

    double pedestalScale;
    double pedestalSpacing;
    if (this.pedestal != null) {
      pedestalScale = this.pedestal.getScale();
      pedestalSpacing = pedestal.getSpacingPixels();
    } else {
      pedestalScale = 0d;
      pedestalSpacing = 0d;
    }

    GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.

    this.setDepthFunc(dc, uIcon, screenPoint);

    gl.glMatrixMode(GL2.GL_MODELVIEW);
    gl.glLoadIdentity();

    Dimension size = icon.getSize();
    double width = size != null ? size.getWidth() : icon.getImageTexture().getWidth(dc);
    double height = size != null ? size.getHeight() : icon.getImageTexture().getHeight(dc);
    gl.glTranslated(
        screenPoint.x - width / 2, screenPoint.y + (pedestalScale * height) + pedestalSpacing, 0d);

    if (icon.isHighlighted()) {
      double heightDelta = this.pedestal != null ? 0 : height / 2; // expand only above the pedestal
      gl.glTranslated(width / 2, heightDelta, 0);
      gl.glScaled(icon.getHighlightScale(), icon.getHighlightScale(), icon.getHighlightScale());
      gl.glTranslated(-width / 2, -heightDelta, 0);
    }

    Rectangle rect =
        new Rectangle(
            (int) (screenPoint.x - width / 2),
            (int) (screenPoint.y),
            (int) width,
            (int) (height + (pedestalScale * height) + pedestalSpacing));

    if (dc.isPickingMode()) {
      // If in picking mode and pick clipping is enabled, check to see if the icon is within the
      // pick volume.
      if (this.isPickFrustumClippingEnabled() && !dc.getPickFrustums().intersectsAny(rect)) {
        // Record feedback data for this WWIcon if feedback is enabled.
        this.recordFeedback(dc, icon, uIcon.point, rect);

        return screenPoint;
      } else {
        java.awt.Color color = dc.getUniquePickColor();
        int colorCode = color.getRGB();
        this.pickSupport.addPickableObject(colorCode, icon, uIcon.getPosition(), false);
        gl.glColor3ub((byte) color.getRed(), (byte) color.getGreen(), (byte) color.getBlue());
      }
    }

    if (icon.getBackgroundTexture() != null)
      this.applyBackground(dc, icon, screenPoint, width, height, pedestalSpacing, pedestalScale);

    if (icon.getImageTexture().bind(dc)) {
      TextureCoords texCoords = icon.getImageTexture().getTexCoords();
      gl.glScaled(width, height, 1d);
      dc.drawUnitQuad(texCoords);
    }

    if (this.pedestal != null && this.pedestal.getImageTexture() != null) {
      gl.glLoadIdentity();
      gl.glTranslated(screenPoint.x - (pedestalScale * (width / 2)), screenPoint.y, 0d);
      gl.glScaled(width * pedestalScale, height * pedestalScale, 1d);

      if (this.pedestal.getImageTexture().bind(dc)) {
        TextureCoords texCoords = this.pedestal.getImageTexture().getTexCoords();
        dc.drawUnitQuad(texCoords);
      }
    }

    // Record feedback data for this WWIcon if feedback is enabled.
    this.recordFeedback(dc, icon, uIcon.point, rect);

    return screenPoint;
  }