home *** CD-ROM | disk | FTP | other *** search
/ IRIX 6.5 Applications 2004 May / SGI IRIX 6.5 Applications 2004 May.iso / dist / java3d.idb / usr / demos / java / j3d / programs / examples / PureImmediate / PureImmediateStereo.java.z / PureImmediateStereo.java
Encoding:
Java Source  |  2003-08-08  |  8.2 KB  |  260 lines
  1. /*
  2.  *    @(#)PureImmediateStereo.java 1.4 02/10/21 13:53:11
  3.  *
  4.  * Copyright (c) 1996-2002 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that the following conditions
  8.  * are met:
  9.  *
  10.  * - Redistributions of source code must retain the above copyright
  11.  *   notice, this list of conditions and the following disclaimer.
  12.  *
  13.  * - Redistribution in binary form must reproduce the above copyright
  14.  *   notice, this list of conditions and the following disclaimer in
  15.  *   the documentation and/or other materials provided with the
  16.  *   distribution.
  17.  *
  18.  * Neither the name of Sun Microsystems, Inc. or the names of
  19.  * contributors may be used to endorse or promote products derived
  20.  * from this software without specific prior written permission.
  21.  *
  22.  * This software is provided "AS IS," without a warranty of any
  23.  * kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND
  24.  * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,
  25.  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY
  26.  * EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES
  27.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  28.  * DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN
  29.  * OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR
  30.  * FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
  31.  * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
  32.  * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE SOFTWARE,
  33.  * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
  34.  *
  35.  * You acknowledge that Software is not designed,licensed or intended
  36.  * for use in the design, construction, operation or maintenance of
  37.  * any nuclear facility.
  38.  */
  39.  
  40. import java.applet.Applet;
  41. import java.awt.*;
  42. import java.util.*;
  43. import java.awt.event.*;
  44. import com.sun.j3d.utils.applet.MainFrame;
  45. import com.sun.j3d.utils.universe.*;
  46. import com.sun.j3d.utils.geometry.*;
  47. import javax.media.j3d.*;
  48. import javax.vecmath.*;
  49.  
  50. /**
  51.  * Pure immediate mode stereo example program for stereo. In pure 
  52.  * immediate mode, the renderer must be stopped on the Canvas being 
  53.  * rendered into. In our example, this is done immediately after the 
  54.  * canvas is created. A separate thread is started up to do the 
  55.  * immediate mode rendering.
  56.  */
  57. public class PureImmediateStereo extends Applet implements Runnable {
  58.  
  59.     // Set this to true when the graphics card use shared z buffer 
  60.     // in stereo mode.
  61.     public static String defaultSharedStereoZbuffer = Boolean.TRUE.toString();
  62.  
  63.     private boolean sharedStereoZbuffer;
  64.     private boolean stereoSupport;    
  65.     private Canvas3D canvas;
  66.     private GraphicsContext3D gc;
  67.     private Shape3D leftConeBody, rightConeBody;
  68.     private Shape3D leftConeCap, rightConeCap;
  69.     private Transform3D cmt = new Transform3D();
  70.     private Vector3f leftTrans, rightTrans;
  71.  
  72.     // One rotation (2*PI radians) every 6 seconds
  73.     private Alpha rotAlpha = new Alpha(-1, 6000);
  74.     private SimpleUniverse u = null;
  75.     private double angle;
  76.  
  77.     // Compute data which is common for both
  78.     // left and right eye
  79.     void computeSharedData() {
  80.     // Compute angle of rotation based on alpha value
  81.     angle = rotAlpha.value() * 2.0*Math.PI;
  82.     cmt.rotY(angle);    
  83.     }
  84.  
  85.     // Render the geometry in right eye
  86.     void renderLeft() {
  87.      cmt.setTranslation(leftTrans);
  88.     gc.setModelTransform(cmt);
  89.  
  90.     if (sharedStereoZbuffer) {
  91.         // Graphics card shared same z buffer in stereo mode,
  92.         // in this case we have to explicitly clearing both
  93.         // frame buffers.
  94.         gc.clear();         
  95.     }
  96.     gc.draw(leftConeBody);
  97.     gc.draw(leftConeCap);
  98.     }
  99.  
  100.     // Render the geometry for right eye
  101.      void renderRight() {
  102.     cmt.setTranslation(rightTrans);
  103.     gc.setModelTransform(cmt);
  104.  
  105.     if (sharedStereoZbuffer) {
  106.         // Graphics card shared same z buffer in stereo mode,
  107.         // in this case we have to explicitly clearing both
  108.         // frame buffers.
  109.         gc.clear();         
  110.     }
  111.     gc.draw(rightConeBody);
  112.     gc.draw(rightConeCap);
  113.     }
  114.  
  115.     //
  116.     // Run method for our immediate mode rendering thread.
  117.     //
  118.     public void run() {
  119.     // Set up Graphics context
  120.     gc = canvas.getGraphicsContext3D();
  121.  
  122.     // We always need to set this for PureImmediate 
  123.     // stereo mode
  124.         gc.setBufferOverride(true);
  125.  
  126.     Color3f lightColor = new Color3f(1, 1, 1);
  127.     Vector3f lightDir = new Vector3f(0, 0, -1);
  128.     DirectionalLight light = new DirectionalLight(lightColor,
  129.                               lightDir);
  130.                       
  131.     gc.addLight(light);
  132.  
  133.     Appearance redApp = new Appearance();
  134.     Appearance greenApp = new Appearance();
  135.     Color3f ambientColor = new Color3f(0, 0, 0);
  136.     Color3f emissiveColor = new Color3f(0, 0, 0);    
  137.     Color3f diffuseColor =  new Color3f(1, 0, 0);    
  138.     Color3f specularColor =  new Color3f(1, 1, 1);    
  139.     redApp.setMaterial(new Material(ambientColor, emissiveColor,
  140.                     diffuseColor, specularColor, 5));
  141.     diffuseColor =  new Color3f(0, 1, 0);    
  142.  
  143.     greenApp.setMaterial(new Material(ambientColor, emissiveColor,
  144.                       diffuseColor, specularColor, 5));
  145.  
  146.     // Set up geometry
  147.     Cone leftCone = new Cone(0.4f, 0.6f,
  148.                  Primitive.GENERATE_NORMALS, redApp);
  149.     Cone rightCone = new Cone(0.4f, 0.6f,
  150.                   Primitive.GENERATE_NORMALS, greenApp);
  151.     leftConeBody  = leftCone.getShape(Cone.BODY);
  152.     leftConeCap   = leftCone.getShape(Cone.CAP);
  153.  
  154.     rightConeBody = rightCone.getShape(Cone.BODY);
  155.     rightConeCap  = rightCone.getShape(Cone.CAP);
  156.     leftTrans = new Vector3f(-0.6f, 0, 0); 
  157.     rightTrans = new Vector3f(0.6f, 0, 0);     
  158.  
  159.  
  160.     while (true) {
  161.         // compute data which is can be used
  162.         // for both left and right eye
  163.         computeSharedData();
  164.  
  165.         if (stereoSupport) {        
  166.         if (!sharedStereoZbuffer) {
  167.             gc.setStereoMode(GraphicsContext3D.STEREO_BOTH);        
  168.             // This clear both left and right buffers, we
  169.             // must set STEREO_BOTH before it. Otherwise
  170.             // it only clear LEFT or RIGHT buffer unless
  171.             // this is invoke twice for each buffer.
  172.             gc.clear(); 
  173.         }
  174.  
  175.         gc.setStereoMode(GraphicsContext3D.STEREO_LEFT);
  176.         renderLeft();
  177.         
  178.         gc.setStereoMode(GraphicsContext3D.STEREO_RIGHT);
  179.         renderRight();
  180.         } else {
  181.         gc.clear(); 
  182.         renderLeft();
  183.         }
  184.  
  185.         // This swap both left and right buffers so 
  186.         // there is no need to set STEREO_BOTH before it
  187.         canvas.swap();
  188.  
  189.         // Be polite to other threads !
  190.         Thread.yield();
  191.     }
  192.     }
  193.  
  194.  
  195.     public PureImmediateStereo() {
  196.     }
  197.  
  198.     //
  199.     // init: create the canvas, stop the renderer,
  200.     // create the universe, and start the drawing thread.
  201.     //
  202.     public void init() {
  203.     setLayout(new BorderLayout());
  204.  
  205.     // Preferred to use Stereo 
  206.     GraphicsConfigTemplate3D gct = new GraphicsConfigTemplate3D();
  207.         gct.setStereo(GraphicsConfigTemplate3D.PREFERRED);
  208.  
  209.         GraphicsConfiguration config = 
  210.         GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getBestConfiguration(gct);
  211.  
  212.         canvas = new Canvas3D(config);
  213.     Map map = canvas.queryProperties();
  214.  
  215.     stereoSupport = canvas.getStereoAvailable();
  216.  
  217.     if (stereoSupport) {
  218.         System.out.println("This machine support stereo, you should see a red cone on the left and green cone on the right.");
  219.         // User can overide the above default behavior using
  220.         // java3d property.
  221.         String str = System.getProperty("j3d.sharedstereozbuffer",
  222.                         defaultSharedStereoZbuffer);
  223.         sharedStereoZbuffer = (new Boolean(str)).booleanValue();
  224.     } else {
  225.         System.out.println("Stereo is not support, you should only see the left red cone.");
  226.     }
  227.     
  228.     if (!canvas.getDoubleBufferAvailable()) {
  229.         System.out.println("Double buffer is not support !");
  230.     }
  231.  
  232.     // we must stop the Renderer in PureImmediate mode
  233.         canvas.stopRenderer();
  234.     add("Center", canvas);
  235.  
  236.     // Create the universe and viewing branch
  237.     u = new SimpleUniverse(canvas);
  238.  
  239.         // This will move the ViewPlatform back a bit so the
  240.         // objects in the scene can be viewed.
  241.         u.getViewingPlatform().setNominalViewingTransform();
  242.  
  243.     // Start a new thread that will continuously render
  244.     (new Thread(this)).start();
  245.     }
  246.  
  247.     // Cleanup all Java3D threads and memory when this applet exit
  248.     public void destroy() {
  249.     u.cleanup();
  250.     }
  251.  
  252.     //
  253.     // The following allows PureImmediateStereo to be run as an application
  254.     // as well as an applet
  255.     //
  256.     public static void main(String[] args) {
  257.     new MainFrame(new PureImmediateStereo(), 512, 256);
  258.     }
  259. }
  260.