Java Tips - Rendering a Java3D 3D Text object with a custom extrusion


import java.applet.Applet;

import java.awt.BorderLayout;

import java.awt.Font;

import java.awt.GraphicsConfigTemplate;

import java.awt.GraphicsDevice;

import java.awt.GraphicsEnvironment;

import java.awt.Shape;

import java.io.File;

import java.net.URL;

import java.util.Vector;



import javax.media.j3d.Alpha;

import javax.media.j3d.Appearance;

import javax.media.j3d.AudioDevice;

import javax.media.j3d.Background;

import javax.media.j3d.BoundingSphere;

import javax.media.j3d.Bounds;

import javax.media.j3d.BranchGroup;

import javax.media.j3d.Canvas3D;

import javax.media.j3d.Font3D;

import javax.media.j3d.FontExtrusion;

import javax.media.j3d.GraphicsConfigTemplate3D;

import javax.media.j3d.Group;

import javax.media.j3d.Locale;

import javax.media.j3d.Material;

import javax.media.j3d.PhysicalBody;

import javax.media.j3d.PhysicalEnvironment;

import javax.media.j3d.PolygonAttributes;

import javax.media.j3d.RotationInterpolator;

import javax.media.j3d.Shape3D;

import javax.media.j3d.Text3D;

import javax.media.j3d.Transform3D;

import javax.media.j3d.TransformGroup;

import javax.media.j3d.View;

import javax.media.j3d.ViewPlatform;

import javax.media.j3d.VirtualUniverse;

import javax.vecmath.Color3f;

import javax.vecmath.Point3d;

import javax.vecmath.Point3f;

import javax.vecmath.Vector3d;



import com.sun.j3d.audioengines.javasound.JavaSoundMixer;

import com.sun.j3d.utils.applet.MainFrame;



/**

 * Renders a Java 3D 3D Text objects with a custom extrusion.

 */

public class Text3DTest extends Java3dApplet {

  private static int m_kWidth = 400;



  private static int m_kHeight = 400;



  public Text3DTest() {

    initJava3d();

  }



  protected double getScale() {

    return 0.2;

  }



  protected BranchGroup createSceneBranchGroup() {

    BranchGroup objRoot = super.createSceneBranchGroup();



    TransformGroup objTrans = new TransformGroup();

    objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);

    objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);



    BoundingSphere bounds = new BoundingSphere(new Point3d(0.0, 0.0, 0.0),

        100.0);



    Transform3D yAxis = new Transform3D();

    Alpha rotationAlpha = new Alpha(-1, Alpha.INCREASING_ENABLE, 0, 0,

        4000, 0, 4000, 0, 0, 0);



    TornadoRotation rotator = new TornadoRotation(rotationAlpha, objTrans,

        yAxis, 0.0f, (float) Math.PI * 2.0f);

    rotator.setSchedulingBounds(bounds);

    objTrans.addChild(rotator);



    objTrans.addChild(createText3D(rotator, "setString", 1, 10.0f, 6.0f,

        Text3D.PATH_RIGHT));

    objRoot.addChild(objTrans);



    return objRoot;

  }



  TransformGroup createText3D(TornadoRotation rotator, String szText,

      int nSize, float scale, float trans, int nPath) {

    TransformGroup tg = new TransformGroup();

    Transform3D t3d = new Transform3D();

    t3d.setScale(scale);

    t3d.setTranslation(new Vector3d(0.0, trans, -10.0));

    tg.setTransform(t3d);



    // use a customized FontExtrusion object to control the depth of the

    // text

    double X1 = 0;

    double Y1 = 0;

    double X2 = 3;

    double Y2 = 0;

    Shape extrusionShape = new java.awt.geom.Line2D.Double(X1, Y1, X2, Y2);



    FontExtrusion fontEx = new FontExtrusion(extrusionShape);



    Font3D f3d = new Font3D(new Font("TimesRoman", Font.PLAIN, nSize),

        fontEx);



    TornadoText3D text3D = new TornadoText3D(f3d, szText, new Point3f(0.0f,

        0.0f, 0.0f), Text3D.ALIGN_CENTER, nPath);



    rotator.addTornadoText3D(text3D);



    // create an appearance

    Color3f black = new Color3f(0.1f, 0.1f, 0.1f);

    Color3f objColor = new Color3f(0.2f, 0.2f, 0.2f);



    Appearance app = new Appearance();

    app.setMaterial(new Material(objColor, black, objColor, black, 90.0f));



    // render as a wireframe

    PolygonAttributes polyAttrbutes = new PolygonAttributes();

    polyAttrbutes.setPolygonMode(PolygonAttributes.POLYGON_LINE);

    polyAttrbutes.setCullFace(PolygonAttributes.CULL_NONE);

    app.setPolygonAttributes(polyAttrbutes);



    tg.addChild(new Shape3D(text3D, app));

    return tg;

  }



  public static void main(String[] args) {

    Text3DTest text3DTest = new Text3DTest();

    text3DTest.saveCommandLineArguments(args);



    new MainFrame(text3DTest, m_kWidth, m_kHeight);

  }

}



class TornadoRotation extends RotationInterpolator {

  Vector m_Text3DVector = null;



  public TornadoRotation(Alpha alpha, TransformGroup target,

      Transform3D axisOfRotation, float minimumAngle, float maximumAngle) {

    super(alpha, target, axisOfRotation, minimumAngle, maximumAngle);



    m_Text3DVector = new Vector();

  }



  public void addTornadoText3D(TornadoText3D text3D) {

    m_Text3DVector.add(text3D);

  }



  public void processStimulus(java.util.Enumeration criteria) {

    super.processStimulus(criteria);



    /*

     * for( int n = 0; n < m_Text3DVector.size(); n++ ) { ((TornadoText3D)

     * m_Text3DVector.get( n )).onFrameUpdate(); }

     */

  }

}



class TornadoText3D extends Text3D {

  public TornadoText3D() {

    super();

    setDefaultAttributes();

  }



  public TornadoText3D(Font3D font3D) {

    super(font3D);

    setDefaultAttributes();

  }



  public TornadoText3D(Font3D font3D, java.lang.String string) {

    super(font3D, string);

    setDefaultAttributes();

  }



  public TornadoText3D(Font3D font3D, java.lang.String string,

      Point3f position) {

    super(font3D, string, position);

    setDefaultAttributes();

  }



  public TornadoText3D(Font3D font3D, java.lang.String string,

      Point3f position, int alignment, int path) {

    super(font3D, string, position, alignment, path);

    setDefaultAttributes();

  }



  protected void setDefaultAttributes() {

    setCapability(ALLOW_ALIGNMENT_READ);

    setCapability(ALLOW_ALIGNMENT_WRITE);



    setCapability(ALLOW_CHARACTER_SPACING_READ);

    setCapability(ALLOW_CHARACTER_SPACING_WRITE);



    setCapability(ALLOW_FONT3D_READ);

    setCapability(ALLOW_FONT3D_WRITE);



    setCapability(ALLOW_PATH_READ);

    setCapability(ALLOW_PATH_WRITE);



    setCapability(ALLOW_POSITION_READ);

    setCapability(ALLOW_POSITION_READ);



    setCapability(ALLOW_STRING_READ);

    setCapability(ALLOW_STRING_WRITE);

  }



  public void onFrameUpdate() {

    setString(getString() + ".");

  }

}



/*******************************************************************************

 * Copyright (C) 2001 Daniel Selman

 * 

 * First distributed with the book "Java 3D Programming" by Daniel Selman and

 * published by Manning Publications. http://manning.com/selman

 * 

 * This program is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License as published by the Free Software

 * Foundation, version 2.

 * 

 * This program is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more

 * details.

 * 

 * The license can be found on the WWW at: http://www.fsf.org/copyleft/gpl.html

 * 

 * Or by writing to: Free Software Foundation, Inc., 59 Temple Place - Suite

 * 330, Boston, MA 02111-1307, USA.

 * 

 * Authors can be contacted at: Daniel Selman: 
 This e-mail address is being protected from spam bots, you need JavaScript enabled to view it
 

 * 

 * If you make changes you think others would like, please contact one of the

 * authors or someone at the www.j3d.org web site.

 ******************************************************************************/



//*****************************************************************************

/**

 * Java3dApplet

 * 

 * Base class for defining a Java 3D applet. Contains some useful methods for

 * defining views and scenegraphs etc.

 * 

 * @author Daniel Selman

 * @version 1.0

 */

//*****************************************************************************



abstract class Java3dApplet extends Applet {

  public static int m_kWidth = 300;



  public static int m_kHeight = 300;



  protected String[] m_szCommandLineArray = null;



  protected VirtualUniverse m_Universe = null;



  protected BranchGroup m_SceneBranchGroup = null;



  protected Bounds m_ApplicationBounds = null;



  //  protected com.tornadolabs.j3dtree.Java3dTree m_Java3dTree = null;



  public Java3dApplet() {

  }



  public boolean isApplet() {

    try {

      System.getProperty("user.dir");

      System.out.println("Running as Application.");

      return false;

    } catch (Exception e) {

    }



    System.out.println("Running as Applet.");

    return true;

  }



  public URL getWorkingDirectory() throws java.net.MalformedURLException {

    URL url = null;



    try {

      File file = new File(System.getProperty("user.dir"));

      System.out.println("Running as Application:");

      System.out.println("   " + file.toURL());

      return file.toURL();

    } catch (Exception e) {

    }



    System.out.println("Running as Applet:");

    System.out.println("   " + getCodeBase());



    return getCodeBase();

  }



  public VirtualUniverse getVirtualUniverse() {

    return m_Universe;

  }



  //public com.tornadolabs.j3dtree.Java3dTree getJ3dTree() {

  //return m_Java3dTree;

  //  }



  public Locale getFirstLocale() {

    java.util.Enumeration e = m_Universe.getAllLocales();



    if (e.hasMoreElements() != false)

      return (Locale) e.nextElement();



    return null;

  }



  protected Bounds getApplicationBounds() {

    if (m_ApplicationBounds == null)

      m_ApplicationBounds = createApplicationBounds();



    return m_ApplicationBounds;

  }



  protected Bounds createApplicationBounds() {

    m_ApplicationBounds = new BoundingSphere(new Point3d(0.0, 0.0, 0.0),

        100.0);

    return m_ApplicationBounds;

  }



  protected Background createBackground() {

    Background back = new Background(new Color3f(0.9f, 0.9f, 0.9f));

    back.setApplicationBounds(createApplicationBounds());

    return back;

  }



  public void initJava3d() {

    //  m_Java3dTree = new com.tornadolabs.j3dtree.Java3dTree();

    m_Universe = createVirtualUniverse();



    Locale locale = createLocale(m_Universe);



    BranchGroup sceneBranchGroup = createSceneBranchGroup();



    ViewPlatform vp = createViewPlatform();

    BranchGroup viewBranchGroup = createViewBranchGroup(

        getViewTransformGroupArray(), vp);



    createView(vp);



    Background background = createBackground();



    if (background != null)

      sceneBranchGroup.addChild(background);



    //    m_Java3dTree.recursiveApplyCapability(sceneBranchGroup);

    //  m_Java3dTree.recursiveApplyCapability(viewBranchGroup);



    locale.addBranchGraph(sceneBranchGroup);

    addViewBranchGroup(locale, viewBranchGroup);



    onDoneInit();

  }



  protected void onDoneInit() {

    //  m_Java3dTree.updateNodes(m_Universe);

  }



  protected double getScale() {

    return 1.0;

  }



  public TransformGroup[] getViewTransformGroupArray() {

    TransformGroup[] tgArray = new TransformGroup[1];

    tgArray[0] = new TransformGroup();



    // move the camera BACK a little...

    // note that we have to invert the matrix as

    // we are moving the viewer

    Transform3D t3d = new Transform3D();

    t3d.setScale(getScale());

    t3d.setTranslation(new Vector3d(0.0, 0.0, -20.0));

    t3d.invert();

    tgArray[0].setTransform(t3d);



    return tgArray;

  }



  protected void addViewBranchGroup(Locale locale, BranchGroup bg) {

    locale.addBranchGraph(bg);

  }



  protected Locale createLocale(VirtualUniverse u) {

    return new Locale(u);

  }



  protected BranchGroup createSceneBranchGroup() {

    m_SceneBranchGroup = new BranchGroup();

    return m_SceneBranchGroup;

  }



  protected View createView(ViewPlatform vp) {

    View view = new View();



    PhysicalBody pb = createPhysicalBody();

    PhysicalEnvironment pe = createPhysicalEnvironment();



    AudioDevice audioDevice = createAudioDevice(pe);



    if (audioDevice != null) {

      pe.setAudioDevice(audioDevice);

      audioDevice.initialize();

    }



    view.setPhysicalEnvironment(pe);

    view.setPhysicalBody(pb);



    if (vp != null)

      view.attachViewPlatform(vp);



    view.setBackClipDistance(getBackClipDistance());

    view.setFrontClipDistance(getFrontClipDistance());



    Canvas3D c3d = createCanvas3D();

    view.addCanvas3D(c3d);

    addCanvas3D(c3d);



    return view;

  }



  protected PhysicalBody createPhysicalBody() {

    return new PhysicalBody();

  }



  protected AudioDevice createAudioDevice(PhysicalEnvironment pe) {

    JavaSoundMixer javaSoundMixer = new JavaSoundMixer(pe);



    if (javaSoundMixer == null)

      System.out.println("create of audiodevice failed");



    return javaSoundMixer;

  }



  protected PhysicalEnvironment createPhysicalEnvironment() {

    return new PhysicalEnvironment();

  }



  protected float getViewPlatformActivationRadius() {

    return 100;

  }



  protected ViewPlatform createViewPlatform() {

    ViewPlatform vp = new ViewPlatform();

    vp.setViewAttachPolicy(View.RELATIVE_TO_FIELD_OF_VIEW);

    vp.setActivationRadius(getViewPlatformActivationRadius());



    return vp;

  }



  protected Canvas3D createCanvas3D() {

    GraphicsConfigTemplate3D gc3D = new GraphicsConfigTemplate3D();

    gc3D.setSceneAntialiasing(GraphicsConfigTemplate.PREFERRED);

    GraphicsDevice gd[] = GraphicsEnvironment.getLocalGraphicsEnvironment()

        .getScreenDevices();



    Canvas3D c3d = new Canvas3D(gd[0].getBestConfiguration(gc3D));

    c3d.setSize(getCanvas3dWidth(c3d), getCanvas3dHeight(c3d));



    return c3d;

  }



  protected int getCanvas3dWidth(Canvas3D c3d) {

    return m_kWidth;

  }



  protected int getCanvas3dHeight(Canvas3D c3d) {

    return m_kHeight;

  }



  protected double getBackClipDistance() {

    return 100.0;

  }



  protected double getFrontClipDistance() {

    return 1.0;

  }



  protected BranchGroup createViewBranchGroup(TransformGroup[] tgArray,

      ViewPlatform vp) {

    BranchGroup vpBranchGroup = new BranchGroup();



    if (tgArray != null && tgArray.length > 0) {

      Group parentGroup = vpBranchGroup;

      TransformGroup curTg = null;



      for (int n = 0; n < tgArray.length; n++) {

        curTg = tgArray[n];

        parentGroup.addChild(curTg);

        parentGroup = curTg;

      }



      tgArray[tgArray.length - 1].addChild(vp);

    } else

      vpBranchGroup.addChild(vp);



    return vpBranchGroup;

  }



  protected void addCanvas3D(Canvas3D c3d) {

    setLayout(new BorderLayout());

    add(c3d, BorderLayout.CENTER);

    doLayout();

  }



  protected VirtualUniverse createVirtualUniverse() {

    return new VirtualUniverse();

  }



  protected void saveCommandLineArguments(String[] szArgs) {

    m_szCommandLineArray = szArgs;

  }



  protected String[] getCommandLineArguments() {

    return m_szCommandLineArray;

  }

}
Related Tips
