/**
  * Returns the location in world space of the point (x, y) on the screen.
  *
  * @param x x coordinate in the image
  * @param y y coordinate in the image
  * @return true if there is an object at x, y , false otherwise
  */
 public boolean getPoint(int x, int y, double xyz[]) {
   if (renderer.bufferg == false) {
     renderer.bufferg = true;
     isDamage = true;
   }
   return renderer.getPoint(x, y, xyz);
 }
  /** main renderer */
  public void run() {

    // MEASURE ELAPSED TIME AND FRAMERATE
    elapsed += getCurrentTime() - currentTime;
    currentTime = getCurrentTime();

    if (isDamage) {

      frameRate = .9 * frameRate + .1 / elapsed;
      elapsed = 0;

      // LET THE APPLICATION PROGRAMMER MOVE THINGS INTO PLACE

      identity(); // APPLIC. MATRIX STARTS UNTRANSFORMED
      // isDamage = true;

      renderer.rotateView(theta, phi);
      theta = phi = 0;

      ianimate(currentTime - startTime);
      // APPLICATION ANIMATES THINGS

      // SHADE AND SCAN CONVERT GEOMETRY INTO FRAME BUFFER
      renderer.refresh();
      renderer.render();

      // KEEP REFINING LEVEL OF DETAIL UNTIL PERFECT (WHEN LOD=1)

      if (renderer.lod > 1) {
        isDamage = true;
        renderer.lod--;
      }
    }
  }
 /**
  * Listens for mouse release and controls aspects of the renderer. A release in the upper left
  * corner toggles {@link Renderer#tableMode}. A release in the upper right corner toggle
  * visibility of the {@link Material#table}display. When true, the current material table is
  * displayed in the upper left corner of the window. Position of the mouse determines current
  * material. A release in the lower right toggles {@link Renderer#showMesh}
  *
  * @param event Event
  * @param x current x coordinate
  * @param y current y coordinate
  * @return true
  */
 public boolean mouseUp(int x, int y) {
   Renderer.setDragging(false);
   if (x < 35 && y < 35) {
     Renderer.tableMode = !Renderer.tableMode;
   }
   if (x > W - 35 && y < 35) {
     seeMaterial = !seeMaterial;
     renderer.bufferg = !renderer.bufferg;
     damage();
   }
   if (x > W - 35 && y > H - 35) {
     renderer.showMesh = !renderer.showMesh;
     damage();
   }
   return true;
 }
 /**
  * Adds light source with direction (x, y, z) & color (r, g, b). Arguments x,y,z indicate light
  * direction. Arguments r,g,b indicate light direction.
  *
  * @see Renderer#addLight(double x,double y,double z, double r,double g,double b)
  */
 public void addLight(
     double x,
     double y,
     double z, // ADD A LIGHT SOURCE
     double r,
     double g,
     double b) {
   renderer.addLight(x, y, z, r, g, b);
 }
 /**
  * Initializes the applet and internal variables. To initialize components of the application
  * program use {@link #initialize()}.
  *
  * @see #initialize()
  */
 public void init() {
   startTime = getCurrentTime();
   world = renderer.getWorld(); // GET ROOT OF GEOMETRY
   for (int i = 0; i < matrix.length; i++) matrix[i] = new Matrix();
   identity();
   initialize();
   if (world != null && world.child != null)
     for (int n = 0; n < world.child.length; n++)
       if (world.child[n] != null && world.child[n].material != null)
         mat = world.child[n].material;
 }
 /**
  * Handles commands received (generally for unicode commands from the KeyListener, but also for
  * commands from any other sources, like buttons from webpages) : various default control keys to
  * modify render style (Use CTRL + key).
  *
  * <p>'e' - toggles {@link Renderer#showMesh}, that just displays the shapes as mesh wireframes
  * <br>
  * 'l' - toggles {@link Renderer#getOutline()}which produces a sketch-line drawing rendition of
  * the scene <br>
  * 'm' - toggles {@link Renderer#seeMesh}which determines mesh visibility <br>
  * 't' - toggles global texture manipulation method (MIP on/off) (@link Texture#useMIP)
  *
  * <p>
  *
  * @param event Event
  * @param key value of the key released
  * @return true if one of the above keys was just released, false otherwise.
  */
 public boolean processCommand(int key) {
   switch (key) {
     case 'e' - ('a' - 1):
       renderer.showMesh = !renderer.showMesh;
       damage();
       return true;
     case 'l' - ('a' - 1):
       renderer.outline(-renderer.getOutline());
       damage();
       return true;
     case 'm' - ('a' - 1):
       renderer.seeMesh = !renderer.seeMesh;
       damage();
       return true;
     case 't' - ('a' - 1):
       Texture.useMIP = !Texture.useMIP;
       damage();
       return true;
   }
   return false;
 }
  /**
   * Dragging the mouse causes gradual view rotation in the phi and theta directions.
   *
   * <p>
   *
   * @param event Event
   * @param x new x coordinate
   * @param y new y coordinate
   */
  public boolean mouseDrag(int x, int y) {

    if (Renderer.isDragging()) {
      theta += .03 * (double) (x - mx); // HORIZONTAL VIEW ROTATION
      phi += .03 * (double) (y - my); // VERTICAL VIEW ROTATION
      mx = x;
      my = y;
    }
    if (frameRate < 10 && renderer.lod < 4) if (enableLod) renderer.lod++;

    isDamage = true;
    return true;
  }
 /**
  * @param m
  * @param n
  * @param w
  * @param h
  * @param pix
  */
 public InteractiveRenderer(int m, int n, int w, int h) {
   W = w;
   H = h;
   renderer = new Renderer();
   pixels = renderer.init(W, H);
   Geometry g = this.add();
   texture = new Texture(pixels, W, H, "grid", false);
   Material material = new Material();
   material.setTexture(texture);
   g.setMaterial(material);
   g.setDoubleSided(true);
   g.mesh(m, n);
   g.name = "mesh";
   init();
 }
 /**
  * Sets the background color ( RGB values range: 0..1)
  *
  * @param r red component 0..1
  * @param g green component 0..1
  * @param b blue component 0..1
  */
 public void setBgColor(double r, double g, double b) {
   renderer.setBgColor(r, g, b);
 }
 /**
  * Sets the camera's focal length.
  *
  * @param value focal length
  * @see Renderer#setFL(double value)
  */
 public void setFL(double value) {
   renderer.setFL(value);
 }
 /** Forces a refresh of the renderer. Sets isDamage true. */
 public void damage() {
   renderer.refresh();
   isDamage = true;
 }
 /**
  * Listener for mouse down. Mouse down starts a view rotation.
  *
  * @return true
  */
 public boolean mouseDown(int x, int y) {
   Renderer.setDragging(true);
   mx = x;
   my = y;
   return true;
 }
Beispiel #13
0
 public void draw(Renderer r) {
   r.draw(this);
 }