baseobject.java

一款机器人仿真软件,功能上与microsoft robotics studio有些相似,但基于Java平台.突出特点是给出了传感器仿真,如声纳,激光等.

/*
 *  Simbad - Robot Simulator
 *  Copyright (C) 2004 Louis Hugues
 *
 *  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; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  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.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 -----------------------------------------------------------------------------
 * $Author: sioulseuguh $ 
 * $Date: 2005/08/07 12:24:57 $
 * $Revision: 1.11 $
 * $Source: /cvsroot/simbad/src/simbad/sim/BaseObject.java,v $
 * 
 * Note :  LH - 12/08/2005 made class public.
 */
package simbad.sim;


import javax.media.j3d.Bounds;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.Group;
import javax.media.j3d.Material;
import javax.media.j3d.Node;
import javax.media.j3d.Transform3D;
import javax.media.j3d.TransformGroup;
import javax.vecmath.Color3f;
import javax.vecmath.Vector3d;
import javax.vecmath.Vector3f;

/**
 * Base class for all objects added in the environment. It mainly contains the translation and
 * rotation transform groups- Descendants should
 * override create3D and call super.create3D().
 *
 */
public  abstract class BaseObject {

    /** Material used for the object body.*/
    Material material;
    /** Branch group corresponding to this object */
    BranchGroup branchGroup;
    /** rotation applied to this object */
    TransformGroup rotationGroup;

    /** translation applied  to this object */
    TransformGroup translationGroup;

    /** Link back to containing world.*/
    World world;
    
    /** indicates that the object is detached from the scenegraph. */
    protected boolean detachedFromSceneGraph;
 
    
    /**  A Group to attach all sub objects.  */
    Group group;
    /** Current rotation transform  - same  transform as in rotationGroup */ 
    Transform3D rotation;
    /** Current translation transform  - same transform as in translationGroup */ 
    Transform3D translation;
    
    /** A prepared color */
    static Color3f black = new Color3f(0.0f, 0.0f, 0.0f);
    /** A prepared color */
    static Color3f white = new Color3f(1.0f, 1.0f, 1.0f);

    /** Indicates that the wall object branch can be compiled to optimize sceneGraph */ 
    boolean compilable;
    
    /** keep direct pointer onto bounds object associated  to group node. */
    protected Bounds localBounds;

    /** if true the  object can be traversed - no collision  */
    boolean canBeTraversed;
    
    BaseObject() {
        compilable = false;  
        canBeTraversed = false;
        // Material for object body.
        material = new Material();
        material.setCapability(Material.ALLOW_COMPONENT_WRITE);
       
    }

    /** Translates (relative to current pos) the object to given position. */
    public void translateTo(Vector3d t) {
        Transform3D t3d = new Transform3D();
        t3d.setTranslation(t);
        translation.mul(t3d);
        translationGroup.setTransform(translation); 
        
    }

    /** Rotates (relative to current rotation) the object about Y axis. */
   public void rotateY(double angle) {
        Transform3D t3d = new Transform3D();
        t3d.rotY(angle);
        rotation.mul(t3d);
        rotationGroup.setTransform(rotation);
    }
   /** Resets translation and rotation transforms. */
   	void resetTransforms(){
        translation.setIdentity();
        rotation.setIdentity();
        translationGroup.setTransform(translation);
        rotationGroup.setTransform(rotation);
   	}
   
   	/** Create the object geometry. */
    void create3D(boolean allowTransformReadWrite) {
        //STRUCTURE Branch group->Translation Transform Group -> Rotation Transform Group->Group
        
        branchGroup = new BranchGroup();
        branchGroup.setCapability(BranchGroup.ALLOW_LOCAL_TO_VWORLD_READ);
        branchGroup.setCapability(BranchGroup.ALLOW_DETACH);
        
        translation = new Transform3D();
        translation.setIdentity();
        translationGroup = new TransformGroup();
        translationGroup.setTransform(translation);
        branchGroup.addChild(translationGroup);
        if (allowTransformReadWrite){      	
	        translationGroup.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
	        translationGroup.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
	        translationGroup.setCapability(TransformGroup.ALLOW_LOCAL_TO_VWORLD_READ);
	        translationGroup.setCapabilityIsFrequent(TransformGroup.ALLOW_TRANSFORM_WRITE);
	        translationGroup.setCapabilityIsFrequent(TransformGroup.ALLOW_TRANSFORM_READ);
	        translationGroup.setCapabilityIsFrequent(TransformGroup.ALLOW_LOCAL_TO_VWORLD_READ);
        }
        // rotation transform
        rotation = new Transform3D();
        rotation.setIdentity();
        rotationGroup = new TransformGroup();
        rotationGroup.setTransform(rotation);
        translationGroup.addChild(rotationGroup);
        if (allowTransformReadWrite){      	
	        rotationGroup.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
	        rotationGroup.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
	        rotationGroup.setCapability(TransformGroup.ALLOW_LOCAL_TO_VWORLD_READ);
	        rotationGroup.setCapabilityIsFrequent(TransformGroup.ALLOW_TRANSFORM_READ);
	        rotationGroup.setCapabilityIsFrequent(TransformGroup.ALLOW_TRANSFORM_WRITE);
	        rotationGroup.setCapabilityIsFrequent(TransformGroup.ALLOW_LOCAL_TO_VWORLD_READ);
        }
        // Create group to attach all gemotries
        group = new Group();
        group.setCapability(Group.ALLOW_LOCAL_TO_VWORLD_READ);
        // we want to setup the bounds manually
        group.setBoundsAutoCompute(false);
     //   group.setCapability(Group.ALLOW_BOUNDS_READ); // No more needed, use localBounds
        rotationGroup.addChild(group);
        
        }

    void compile(){
        if (compilable) branchGroup.compile();
    }
    final Node getNode() {
        return branchGroup;
    }

    protected void addChild(BaseObject object) {
        group.addChild(object.getNode());
    }

    final void addChild(Node node) {
        group.addChild(node);
      }

    Vector3f getTranslation() {
        Vector3f v = new Vector3f();
        translation.get(v);
        return v;
    }
    TransformGroup getRotationTransformGroup(){
        return rotationGroup;
    }
    TransformGroup getTranslationTransform(){
        return translationGroup;
    }
    Group getGroup(){ return group;}
    
    
    /** Sets the bounds object for collision/interaction detection */
    void setBounds(Bounds bounds){
        localBounds = bounds;
        group.setBounds(bounds);
    }
    Bounds getBounds (){
        return localBounds;
       // return group.getBounds();
    }
 
    
 	 /**
	  * Obtain  translation transform.
	 */
	public void getTranslationTransform(Transform3D t){
	    t.set(translation);
	}
	 /**
	  * Obtain  rotation transform.
	 */
	public void getRotationTransform(Transform3D t){
	    t.set(rotation);
	}

	/** Sets the containing world.*/
	protected void setWorld(World world){
	    this.world = world;
	}
	
    /** Removes object from the scenegraph. */
    public void detach(){
        
        world.detach(this);
        detachedFromSceneGraph = true;
    }
    /** Re-add object to the scenegraph. */
    public void attach(){
        world.attach(this);
        detachedFromSceneGraph = false;
    }
    
    /** Sets the canBeTraversed Flag. */
    public void setCanBeTraversed(boolean canbetraversed){
        this.canBeTraversed = canbetraversed;
    }

   
    /** Gets the canBeTraversed Flag. */
    public boolean getCanBeTraversed(){
        return canBeTraversed;
    }
 
    
	 /** Change the color while the  simulation is running.*/
    public void setColor(Color3f color){
        material.setDiffuseColor(color);
        material.setAmbientColor(color);
    }

}