直接模式渲染 : 渲染 « 三维图形动画 « Java

En
Java
1. 图形用户界面
2. 三维图形动画
3. 高级图形
4. 蚂蚁编译
5. Apache类库
6. 统计图
7. 
8. 集合数据结构
9. 数据类型
10. 数据库JDBC
11. 设计模式
12. 开发相关类
13. EJB3
14. 电子邮件
15. 事件
16. 文件输入输出
17. 游戏
18. 泛型
19. GWT
20. Hibernate
21. 本地化
22. J2EE平台
23. 基于J2ME
24. JDK-6
25. JNDI的LDAP
26. JPA
27. JSP技术
28. JSTL
29. 语言基础知识
30. 网络协议
31. PDF格式RTF格式
32. 映射
33. 常规表达式
34. 脚本
35. 安全
36. Servlets
37. Spring
38. Swing组件
39. 图形用户界面
40. SWT-JFace-Eclipse
41. 线程
42. 应用程序
43. Velocity
44. Web服务SOA
45. 可扩展标记语言
Java 教程
Java » 三维图形动画 » 渲染屏幕截图 
直接模式渲染
直接模式渲染

/*
 *  @(#)PureImmediateStereo.java 1.4 02/10/21 13:53:11
 *
 * Copyright (c) 1996-2002 Sun Microsystems, Inc. All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * - Redistribution in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in
 *   the documentation and/or other materials provided with the
 *   distribution.
 *
 * Neither the name of Sun Microsystems, Inc. or the names of
 * contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.
 *
 * This software is provided "AS IS," without a warranty of any
 * kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND
 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY
 * EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES
 * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
 * DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN
 * OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR
 * FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
 * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
 * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE SOFTWARE,
 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 *
 * You acknowledge that Software is not designed,licensed or intended
 * for use in the design, construction, operation or maintenance of
 * any nuclear facility.
 */

import java.applet.Applet;
import java.awt.BorderLayout;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsEnvironment;
import java.util.Map;

import javax.media.j3d.Alpha;
import javax.media.j3d.Appearance;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.DirectionalLight;
import javax.media.j3d.GraphicsConfigTemplate3D;
import javax.media.j3d.GraphicsContext3D;
import javax.media.j3d.Material;
import javax.media.j3d.Shape3D;
import javax.media.j3d.Transform3D;
import javax.vecmath.Color3f;
import javax.vecmath.Vector3f;

import com.sun.j3d.utils.applet.MainFrame;
import com.sun.j3d.utils.geometry.Cone;
import com.sun.j3d.utils.geometry.Primitive;
import com.sun.j3d.utils.universe.SimpleUniverse;

/**
 * Pure immediate mode stereo example program for stereo. In pure immediate
 * mode, the renderer must be stopped on the Canvas being rendered into. In our
 * example, this is done immediately after the canvas is created. A separate
 * thread is started up to do the immediate mode rendering.
 */
public class PureImmediateStereo extends Applet implements Runnable {

  // Set this to true when the graphics card use shared z buffer
  // in stereo mode.
  public static String defaultSharedStereoZbuffer = Boolean.TRUE.toString();

  private boolean sharedStereoZbuffer;

  private boolean stereoSupport;

  private Canvas3D canvas;

  private GraphicsContext3D gc;

  private Shape3D leftConeBody, rightConeBody;

  private Shape3D leftConeCap, rightConeCap;

  private Transform3D cmt = new Transform3D();

  private Vector3f leftTrans, rightTrans;

  // One rotation (2*PI radians) every 6 seconds
  private Alpha rotAlpha = new Alpha(-16000);

  private SimpleUniverse u = null;

  private double angle;

  // Compute data which is common for both
  // left and right eye
  void computeSharedData() {
    // Compute angle of rotation based on alpha value
    angle = rotAlpha.value() 2.0 * Math.PI;
    cmt.rotY(angle);
  }

  // Render the geometry in right eye
  void renderLeft() {
    cmt.setTranslation(leftTrans);
    gc.setModelTransform(cmt);

    if (sharedStereoZbuffer) {
      // Graphics card shared same z buffer in stereo mode,
      // in this case we have to explicitly clearing both
      // frame buffers.
      gc.clear();
    }
    gc.draw(leftConeBody);
    gc.draw(leftConeCap);
  }

  // Render the geometry for right eye
  void renderRight() {
    cmt.setTranslation(rightTrans);
    gc.setModelTransform(cmt);

    if (sharedStereoZbuffer) {
      // Graphics card shared same z buffer in stereo mode,
      // in this case we have to explicitly clearing both
      // frame buffers.
      gc.clear();
    }
    gc.draw(rightConeBody);
    gc.draw(rightConeCap);
  }

  //
  // Run method for our immediate mode rendering thread.
  //
  public void run() {
    // Set up Graphics context
    gc = canvas.getGraphicsContext3D();

    // We always need to set this for PureImmediate
    // stereo mode
    gc.setBufferOverride(true);

    Color3f lightColor = new Color3f(111);
    Vector3f lightDir = new Vector3f(00, -1);
    DirectionalLight light = new DirectionalLight(lightColor, lightDir);

    gc.addLight(light);

    Appearance redApp = new Appearance();
    Appearance greenApp = new Appearance();
    Color3f ambientColor = new Color3f(000);
    Color3f emissiveColor = new Color3f(000);
    Color3f diffuseColor = new Color3f(100);
    Color3f specularColor = new Color3f(111);
    redApp.setMaterial(new Material(ambientColor, emissiveColor,
        diffuseColor, specularColor, 5));
    diffuseColor = new Color3f(010);

    greenApp.setMaterial(new Material(ambientColor, emissiveColor,
        diffuseColor, specularColor, 5));

    // Set up geometry
    Cone leftCone = new Cone(0.4f0.6f, Primitive.GENERATE_NORMALS, redApp);
    Cone rightCone = new Cone(0.4f0.6f, Primitive.GENERATE_NORMALS,
        greenApp);
    leftConeBody = leftCone.getShape(Cone.BODY);
    leftConeCap = leftCone.getShape(Cone.CAP);

    rightConeBody = rightCone.getShape(Cone.BODY);
    rightConeCap = rightCone.getShape(Cone.CAP);
    leftTrans = new Vector3f(-0.6f00);
    rightTrans = new Vector3f(0.6f00);

    while (true) {
      // compute data which is can be used
      // for both left and right eye
      computeSharedData();

      if (stereoSupport) {
        if (!sharedStereoZbuffer) {
          gc.setStereoMode(GraphicsContext3D.STEREO_BOTH);
          // This clear both left and right buffers, we
          // must set STEREO_BOTH before it. Otherwise
          // it only clear LEFT or RIGHT buffer unless
          // this is invoke twice for each buffer.
          gc.clear();
        }

        gc.setStereoMode(GraphicsContext3D.STEREO_LEFT);
        renderLeft();

        gc.setStereoMode(GraphicsContext3D.STEREO_RIGHT);
        renderRight();
      else {
        gc.clear();
        renderLeft();
      }

      // This swap both left and right buffers so
      // there is no need to set STEREO_BOTH before it
      canvas.swap();

      // Be polite to other threads !
      Thread.yield();
    }
  }

  public PureImmediateStereo() {
  }

  //
  // init: create the canvas, stop the renderer,
  // create the universe, and start the drawing thread.
  //
  public void init() {
    setLayout(new BorderLayout());

    // Preferred to use Stereo
    GraphicsConfigTemplate3D gct = new GraphicsConfigTemplate3D();
    gct.setStereo(GraphicsConfigTemplate3D.PREFERRED);

    GraphicsConfiguration config = GraphicsEnvironment
        .getLocalGraphicsEnvironment().getDefaultScreenDevice()
        .getBestConfiguration(gct);

    canvas = new Canvas3D(config);
    Map map = canvas.queryProperties();

    stereoSupport = canvas.getStereoAvailable();

    if (stereoSupport) {
      System.out
          .println("This machine support stereo, you should see a red cone on the left and green cone on the right.");
      // User can overide the above default behavior using
      // java3d property.
      String str = System.getProperty("j3d.sharedstereozbuffer",
          defaultSharedStereoZbuffer);
      sharedStereoZbuffer = (new Boolean(str)).booleanValue();
    else {
      System.out
          .println("Stereo is not support, you should only see the left red cone.");
    }

    if (!canvas.getDoubleBufferAvailable()) {
      System.out.println("Double buffer is not support !");
    }

    // we must stop the Renderer in PureImmediate mode
    canvas.stopRenderer();
    add("Center", canvas);

    // Create the universe and viewing branch
    u = new SimpleUniverse(canvas);

    // This will move the ViewPlatform back a bit so the
    // objects in the scene can be viewed.
    u.getViewingPlatform().setNominalViewingTransform();

    // Start a new thread that will continuously render
    (new Thread(this)).start();
  }

  // Cleanup all Java3D threads and memory when this applet exit
  public void destroy() {
    u.cleanup();
  }

  //
  // The following allows PureImmediateStereo to be run as an application
  // as well as an applet
  //
  public static void main(String[] args) {
    new MainFrame(new PureImmediateStereo()512256);
  }
}


           
       
Related examples in the same category
1. 用PointArray立即模式和FPS游戏用PointArray立即模式和FPS游戏
2. Mix rendering in immediate and retained mode to produceMix rendering in immediate and retained mode to produce
3. Pure ImmediatePure Immediate
4. PrintFromButton tests renderOffScreenBuffer from a buttonPrintFromButton tests renderOffScreenBuffer from a button
5. Renders a 3D shape using a 3D rendering engine that was written from scratch
www.java2java.com | Contact Us
Copyright 2010 - 2030 Java Source and Support. All rights reserved.
All other trademarks are property of their respective owners.