mjbWorld program - 3D File Formats for saving the model

Programs written in Java or C++ are object oriented and so both data and behavior both represented by an object and stored together. With this program it would be useful to model the 3D world at a higher level, but still keep the object oriented idea of keeping the static data (in this case its shape and appearance) together with its dynamic information (how it behaves). We need a storage format that allows a 3D world to be stored and exchanged with others, using such a high level description.

Many of the existing concepts for modeling 3D worlds come form VRML, these ideas are now being extended in standards like X3D, MPEG4/BIFS and XMT. Since it is intended that this program is based on open standards, then it needs to be based on one (or more) of these standards. However these standards don't yet support physics simulation, for example, so we need to decide which of these standards forms the best base and then design some standard extensions to support physics etc.

3D Open Standards:

VRML

Virtual Reality Modeling Language.

This is a text based representation of a 3D world.

For further information about using VRML with this program link here

MPEG4/BIFS

Moving Pictures Experts Group/ Binary Format for Scenes (ISO/IEC JTCI/SC29/WG11)

MPEG standards are binary (i.e. not text based) standards for streaming audiovisual (such as television signals).

MPEG4 also allows multimedia to be streamed. The BIFS standard provides a way for objects to be added or removed to/from the scene and animate these objects.

This standard takes most of its concepts for a 3D scene graph from VRML, but it adds many more nodes including 2D nodes and human animation nodes. (Unfortunately it does not yet include nodes for physics interaction)

X3D

Extensible 3D

This is a version of VRML which codes the information using XML

Futher info about x3d

XMT

Working Draft 3.0 of ISO/IEC 14496-1 / AMD3

This is a draft proposal for a coding of a standard to encode MPEG-4 in textual format using XML

2D standards

SVG

2D vector graphics and page animation language.

Further info about SVG.


Concepts

Most of the open 3D standards are derived in some way from VRML and the idea of a Scene Graph

PROTOs

In the world, there are things such as animals, plants, manufactured items, buildings, etc. that tend to be repeated in the world with small differences. Rather than building each instance of these types we need a way to abstract out the common features. This is where PROTOs can be used:

For instance if I want lots of spherical objects of different size and colour I could define a PROTO as follows:

PROTO myBlob [field SFFloat.size 3.0 field SFColor.col 1 0 0] {
   Shape {
     appearance Appearance {
       material Material {
         diffuseColor IS col
       }
     }
     geometry Sphere {
       radius IS size
     }
  }
}


myBlob {size 8 col 1 0 1}
myBlob {size 10 col 0 1 1}
myBlob {size 12 col 1 1 0}

How do we implement this? In the case of a program which just displays the scene but does not edit. It is simple just expand out the PROTO calls as follows:

Shape {
   appearance Appearance {
     material Material {
       diffuseColor 1 0 1
     }
   }
   geometry Sphere {
     radius 8
   }
}
Shape {
  appearance Appearance {
    material Material {
      diffuseColor 0 1 1
    }
  }
  geometry Sphere {
    radius 10
  }
}
Shape {
  appearance Appearance {
    material Material {
      diffuseColor 1 1 0
    }
  }
  geometry Sphere {
    radius 12
  }
}

Since this program is an editor we cannot expand out the PROTO when loading the file. This is because we may need to edit the PROTO itself, and also when we save the file we want to keep the PROTO.

Therefore when we load the file we load the information into a set of beans (as described here). The PROTO definition is stored under a protoBean node and calls to the PROTO are stored as protoInstanceBean nodes.

Then then a 3D window is created as set of Java3D nodes has to be created. This is done by traversing the beans, and when a protoInstanceBean is encountered then a copy of the whole structure under the protoBean is created, with Java3D instances, replacing the IS keywords with the appropriate values.



implementation issues of VRML using X3D

For (somewhat) understandable reasons, you've turned the IS syntax inside out. Instead of associating the IS keyword with the field being IS-ed, you put the IS in the PROTO's interface description, with a name reference to the node and field to associate it with. The problem is, node-valued fields aren't described by name in the DTD

=> But that is where XML itself stops. It is not => an object oriented programming language. Any notion of that => has to be specified in the application language and implemented. => XML DOM provides no such implementation. So as we discussed, => the implementation of PROTO has to be in X3D. Yes, there are many things that should be PROTOs, while other things should be XML content. It all depends on the precise scope of X3D. Good candidates for PROTOs in X3D are elements or entities whose primary focus is 3D graphics and geometry. NURBs is an excellent use of PROTO since the idea of a NURB fits within the concept of "geometry." VRML developers thought ahead to allow this kind of extensibility not found in other standards. However, application-specific content, such as the structure of molecules or dynamic models have nothing intrinsically to do with 3D. X3D represents an XML dialect that remains close to the end of a chain of XSLT-type transformations just prior to presentation of the content to the human. PROTOs also serve as a kind of stepping stone toward more complex XML schema development. Don alluded to this in a prior post. Since PROTOs are so well-designed and easy incorporated into a VRML/X3D world, one can begin to build new domain languages using PROTOs, and then graduate later to new languages

The problem ~> with PROTOs is that only a PROTO-aware development tool can ~> recognize them ~> as anything other than simple attributes. I don't want my object type ~> information to be "trapped" inside a PROTO; I want it to be available to ~> *any* XML-aware tool. Hence the type information needs to be ~> maintained on ~> the XML side, not in the PROTOs. Comprende? Bingo. PROTOs were, and still are, an excellent method for starting to "extend" one's domain-specific semantics, but the whole point of XML is to achieve a separation of semantics and style (or presentation).


ROUTEs

This provides an event passing mechanism. See here for details


Mapping to VRML and Java3D

VRML node VRML parameters mjbWorld node mjbWorld parameters java3D
Anchor Anchor {
eventIn MFNode addChildren
eventIn MFNode removeChildren
exposedField MFNode children []
exposedField SFString description ""
exposedField MFString parameter []
exposedField MFString url []
field SFVec3f bboxCenter 0 0 0 # (-,)
field SFVec3f bboxSize -1 -1 -1 # (0,) or -1,-1,-1
}
anchorBean extends groupBean sfstring_m description;
mfstring_m parameter;
mfstring_m url;
this functionality provided by user written Java code
Appearance Appearance {
exposedField SFNode material NULL
exposedField SFNode texture NULL
exposedField SFNode textureTransform NULL
}
appearanceBean

validChildClasses:


materialBean.class,
textureBean.class,
textureTransformBean.class,
textureAttributesBean.class,
coloringAttributesBean.class,
transparencyAttributesBean.class,
coloringAttributesBean.class,
transparencyAttributesBean.class,
renderingAttributesBean.class,
polygonAttributesBean.class,
lineAttributesBean.class,
pointAttributesBean.class,
textureBean.class,

Appearance

ColoringAttributes coloringAttributes
LineAttributes lineAttributes
PointAttributes pointAttributes
PolygonAttributes polygonAttributes
RenderingAttributes renderingAttributes
TransparencyAttributes transparencyAttributes
Material material
Texture texture
TextureAttributes textureAttributes
TextureCoordinateGeneration textureCoordinateGeneration
TextureUnitState[] TextureUnitState

   

AlternateAppearance

Group[] scope
Appearance appearance

   

AuralAttributes

Attribute Gain
Attribute Gain Rolloff
Rolloff scale factor
Auralization
Reflection Coefficient
Reverb Delay
Reverb Bounds
Reverb Order
bounding region.
Reflection Coefficient
Reverberation Delay
Reverberation Bounds
Reverberation Order
Distance Filter
Doppler Effect Model

       

ColoringAttributes

Color3f color
int shadeModel

 

   

LineAttributes

float lineWidth,
int linePattern,
boolean lineAntialiasing
int patternMask
int patternScaleFactor

   

PointAttributes

float pointSize
boolean pointAntialiasing

   

PolygonAttributes

int polygonMode
int cullFace
float polygonOffset
boolean backFaceNormalFlip
float polygonOffsetFactor

   

RenderingAttributes

boolean depthBufferEnable,
boolean depthBufferWriteEnable,
float alphaTestValue,
int alphaTestFunction,
boolean visible,
boolean ignoreVertexColors,
boolean rasterOpEnable,
int rasterOp

   

TextureAttributes

int textureMode
Transform3D transform
Color4f textureBlendColor
int perspCorrectionMode

   

TransparencyAttributes

int tMode
float tVal
int srcBlendFunction
int dstBlendFunction

   

AmbientLight

inherits all methods from javax.media.j3d.Light

AudioClip AudioClip {
exposedField SFString description ""
exposedField SFBool loop FALSE
exposedField SFFloat pitch 1.0 # (0,)
exposedField SFTime startTime 0 # (-,)
exposedField SFTime stopTime 0 # (-,)
exposedField MFString url []
eventOut SFTime duration_changed
eventOut SFBool isActive
}
Not yet supported
Background Background {
eventIn SFBool set_bind
exposedField MFFloat groundAngle [] # [0,/2]
exposedField MFColor groundColor [] # [0,1]
exposedField MFString backUrl []
exposedField MFString bottomUrl []
exposedField MFString frontUrl []
exposedField MFString leftUrl []
exposedField MFString rightUrl []
exposedField MFString topUrl []
exposedField MFFloat skyAngle [] # [0,]
exposedField MFColor skyColor 0 0 0 # [0,1]
eventOut SFBool isBound
}
backgroundBean sfbool_m set_bind;
mffloat_m groundAngle;
mfcolor_m groundColor;
sfimage_m backUrl;
sfimage_m bottomUrl;
sfimage_m frontUrl;
sfimage_m leftUrl;
sfimage_m rightUrl;
sfimage_m topUrl;
mffloat_m skyAngle;
mfcolor_m skyColor;
sfbool_m isBound;
Color background color.
BranchGroup geometry
ImageComponent2D image
   

BackgroundSound

MediaContainer soundData
float initialGain
int loopCount
boolean release
boolean continuous
boolean enable
Bounds region
float priority

    Behavior
Billboard Billboard {
eventIn MFNode addChildren
eventIn MFNode removeChildren
exposedField SFVec3f axisOfRotation 0 1 0 # (-,)
exposedField MFNode children []
field SFVec3f bboxCenter 0 0 0 # (-,)
field SFVec3f bboxSize -1 -1 -1 # (0,) or -1,-1,-1
}

Vector3f alignmentAxis
int alignmentMode()
Point3f rotationPoint
TransformGroup target
criteria.processStimulus

Box Box {
field SFVec3f size 2 2 2 # (0, )
}

boxBean extends geometryBean

geometry nodes hold VRML parameters + conversion to IFS arrays

sfvec3f_m size = new sfvec3f_m(1,1,1); see geometry
   

BranchGroup

SceneGraphPath[] children

Collision Collision {
eventIn MFNode addChildren
eventIn MFNode removeChildren
exposedField MFNode children []
exposedField SFBool collide TRUE
field SFVec3f bboxCenter 0 0 0 # (-,)
field SFVec3f bboxSize -1 -1 -1 # (0,) or -1,-1,-1
field SFNode proxy NULL
eventOut SFTime collideTime
}
collisionBean extends groupBean sfbool_m collide;
sfvec3f_m bboxCenter;
sfvec3f_m bboxSize;
groupBean proxy;
sftime_m collideTime;
Color Color {
exposedField MFColor color [] # [0,1]
}
colorBean mfcolor_m color
ColorInterpolator ColorInterpolator {
eventIn SFFloat set_fraction # (-,)
exposedField MFFloat key [] # (-,)
exposedField MFColor keyValue [] # [0,1]
eventOut SFColor value_changed
}
colorInterpolatorBean sffloat_m set_fraction;
mffloat_m key;
mfcolor_m keyValue;
sfcolor_m value_changed;

Color3f endColor
Color3f startColor
Material target

Cone Cone {
field SFFloat bottomRadius 1 # (0,)
field SFFloat height 2 # (0,)
field SFBool side TRUE
field SFBool bottom TRUE
}

coneBean extends geometryBean

geometry nodes hold VRML parameters + conversion to IFS arrays

sffloat_m bottomRadius = new sffloat_m(1);
sffloat_m height = new sffloat_m(2);
sfbool_m side;
sfbool_m bottom;
see geometry
   

ConeSound

MediaContainer soundData
float initialGain
int loopCount
boolean release
boolean continuous
boolean enable,
Bounds region,
float priority,
Point3f position
Point2f[] frontDistanceAttenuation
Point2f[] backDistanceAttenuation
Vector3f direction
Point3f[] angularAttenuation

Coordinate Coordinate {
exposedField MFVec3f point [] # (-,)
}
coordinateBean mfvec3f_m coord
CoordinateInterpolator CoordinateInterpolator {
eventIn SFFloat set_fraction # (-,)
exposedField MFFloat key [] # (-,)
exposedField MFVec3f keyValue [] # (-,)
eventOut MFVec3f value_changed
}
coordinateInterpolatorBean sffloat_m set_fraction;
mffloat_m key;
mfvec3f_m keyValue;
sfvec3f_m value_changed
Cylinder Cylinder {
field SFBool bottom TRUE
field SFFloat height 2 # (0,)
field SFFloat radius 1 # (0,)
field SFBool side TRUE
field SFBool top TRUE
}

cylinderBean extends geometryBean

geometry nodes hold VRML parameters + conversion to IFS arrays

sfbool_m bottom;
sffloat_m height = new sffloat_m(2);
sffloat_m radius = new sffloat_m(2);
sfbool_m side;
sfbool_m top
see geometry
CylinderSensor CylinderSensor {
exposedField SFBool autoOffset TRUE
exposedField SFFloat diskAngle 0.262 # (0,/2)
exposedField SFBool enabled TRUE
exposedField SFFloat maxAngle -1 # [-2,2]
exposedField SFFloat minAngle 0 # [-2,2]
exposedField SFFloat offset 0 # (-,)
eventOut SFBool isActive
eventOut SFRotation rotation_changed
eventOut SFVec3f trackPoint_changed
}
cylinderSensorBean sfbool_m autoOffset;
sffloat_m diskAngle;
sfbool_m enabled;
sffloat_m maxAngle;
sffloat_m minAngle;
sffloat_m offset;
sfbool_m isActive;
sfrotation_m rotation_changed;
sfvec3f_m trackPoint_changed;
   

DecalGroup

SceneGraphPath[] children

DirectionalLight DirectionalLight {
exposedField SFFloat ambientIntensity 0 # [0,1]
exposedField SFColor color 1 1 1 # [0,1]
exposedField SFVec3f direction 0 0 -1 # (-,)
exposedField SFFloat intensity 1 # [0,1]
exposedField SFBool on TRUE
}
directionalLightBean extends lightBean sfvec3f_m direction

DirectionalLight

inherits all methods from

javax.media.j3d.Light

+

Vector3f direction

ElevationGrid ElevationGrid {
eventIn MFFloat set_height
exposedField SFNode color NULL
exposedField SFNode normal NULL
exposedField SFNode texCoord NULL
field MFFloat height [] # (-,)
field SFBool ccw TRUE
field SFBool colorPerVertex TRUE
field SFFloat creaseAngle 0 # [0,]
field SFBool normalPerVertex TRUE
field SFBool solid TRUE
field SFInt32 xDimension 0 # [0,)
field SFFloat xSpacing 1.0 # (0,)
field SFInt32 zDimension 0 # [0,)
field SFFloat zSpacing 1.0 # (0,)
}

elivationGridBean extends geometryBean

geometry nodes hold VRML parameters + conversion to IFS arrays

sffloat_m set_height;
mffloat_m height;
sfbool_m ccw;
sfbool_m colorPerVertex;
sffloat_m creaseAngle;
sfbool_m normalPerVertex;
sfbool_m solid;
sfint32_m xDimension;
sffloat_m xSpacing;
sfint32_m zDimension;
sffloat_m zSpacing
see geometry
Extrusion Extrusion {
eventIn MFVec2f set_crossSection
eventIn MFRotation set_orientation
eventIn MFVec2f set_scale
eventIn MFVec3f set_spine
field SFBool beginCap TRUE
field SFBool ccw TRUE
field SFBool convex TRUE
field SFFloat creaseAngle 0 # [0,)
field MFVec2f crossSection [ 1 1, 1 -1, -1 -1,
-1 1, 1 1 ] # (-,)
field SFBool endCap TRUE
field MFRotation orientation 0 0 1 0 # [-1,1],(-,)
field MFVec2f scale 1 1 # (0,)
field SFBool solid TRUE
field MFVec3f spine [ 0 0 0, 0 1 0 ] # (-,)
}

extrusionBean extends geometryBean

geometry nodes hold VRML parameters + conversion to IFS arrays

mfvec2f_m scale;
sfbool_m beginCap;
sfbool_m ccw;
sfbool_m convex;
sffloat_m creaseAngle;
mfvec2f_m crossSection;
sfbool_m endCap;
mfrotation_m orientation;
sfbool_m solid;
mfvec3f_m spine;
Fog Fog {
exposedField SFColor color 1 1 1 # [0,1]
exposedField SFString fogType "LINEAR"
exposedField SFFloat visibilityRange 0 # [0,)
eventIn SFBool set_bind
eventOut SFBool isBound
}
fogBean sfcolor_m color;
sfstring_m fogType = new sfstring_m("EXPONENTIAL");
sffloat_m visibilityRange;
sfbool_m set_bind ;
sfbool_m is_Bound

Fog

Group[] scope
Color3f color

ExponentialFog extends Fog

Color3f color
float density

LinearFog extends Fog

Color3f color,
double frontDistance,
double backDistance

FontStyle FontStyle {
field MFString family "SERIF"
field SFBool horizontal TRUE
field MFString justify "BEGIN"
field SFString language ""
field SFBool leftToRight TRUE
field SFFloat size 1.0 # (0,)
field SFFloat spacing 1.0 # [0,)
field SFString style "PLAIN"
field SFBool topToBottom TRUE
}
fontStyleBean mfstring_m family;
sfbool_m horizontal;
mfstring_m justify;
sfstring_m language;
sfbool_m leftToRight;
sffloat_m size;
sffloat_m spacing;
sfstring_m style;
sfbool_m topToBottom
    geometryBean intVertexPerFace = 3;
int mode =0;
int num_indexes;
int num_vertexes;
int num_points;
int num_faces;
boolean b_colorPerVertex = true;
boolean b_normalPerVertex = true;
boolean b_texturePerVertex = true;
sfstring_m mde;
boolean use_existing_arrays = false;
boolean dontUpdateScene = false;

Geometry GeometryArray, GeometryStripArray, IndexedGeometryArray IndexedGeometryStripArray IndexedLineArray IndexedLineStripArray IndexedPointArray IndexedQuadArray IndexedTriangleArray IndexedTriangleFanArray IndexedTriangleStripArray .LineArray LineAttributes LineStripArray,TriangleFanArray TriangleStripArray

Group Group {
eventIn MFNode addChildren
eventIn MFNode removeChildren
exposedField MFNode children []
field SFVec3f bboxCenter 0 0 0 # (-,)
field SFVec3f bboxSize -1 -1 -1 # (0,) or -1,-1,-1
}
groupBean SceneGraphPath[] children
ImageTexture ImageTexture {
exposedField MFString url []
field SFBool repeatS TRUE
field SFBool repeatT TRUE
}

Texture node

ImageTexture,MovieTexture and PixelTexture all map to Texture node

IndexedFaceSet IndexedFaceSet {
eventIn MFInt32 set_colorIndex
eventIn MFInt32 set_coordIndex
eventIn MFInt32 set_normalIndex
eventIn MFInt32 set_texCoordIndex
exposedField SFNode color NULL
exposedField SFNode coord NULL
exposedField SFNode normal NULL
exposedField SFNode texCoord NULL
field SFBool ccw TRUE
field MFInt32 colorIndex [] # [-1,)
field SFBool colorPerVertex TRUE
field SFBool convex TRUE
field MFInt32 coordIndex [] # [-1,)
field SFFloat creaseAngle 0 # [0,)
field MFInt32 normalIndex [] # [-1,)
field SFBool normalPerVertex TRUE
field SFBool solid TRUE
field MFInt32 texCoordIndex [] # [-1,)
}

ifsBean extends geometryBean

geometry nodes hold VRML parameters + conversion to IFS arrays

sfbool_m ccw;
sfbool_m colorPerVertex;
sfbool_m convex;
sffloat_m creaseAngle;
sfbool_m normalPerVertex;
sfbool_m solid
IndexedLineSet IndexedLineSet {
eventIn MFInt32 set_colorIndex
eventIn MFInt32 set_coordIndex
exposedField SFNode color NULL
exposedField SFNode coord NULL
field MFInt32 colorIndex [] # [-1,)
field SFBool colorPerVertex TRUE
field MFInt32 coordIndex [] # [-1,)
}

indexedLineSetBean extends geometryBean

geometry nodes hold VRML parameters + conversion to IFS arrays

sfbool_m colorPerVertex
Inline Inline {
exposedField MFString url []
field SFVec3f bboxCenter 0 0 0 # (-,)
field SFVec3f bboxSize -1 -1 -1 # (0,) or -1,-1,-1
}
inlineBean mfstring_m url;
   

Light

Group[] scope
Color3f color
boolean enable
Group[] scope

    Link
    Locale
LOD LOD {
exposedField MFNode level []
field SFVec3f center 0 0 0 # (-,)
field MFFloat range [] # (0,)
}

LOD

Switch switchNode

     

DistanceLOD

Switch switchNode

Material Material {
exposedField SFFloat ambientIntensity 0.2 # [0,1]
exposedField SFColor diffuseColor 0.8 0.8 0.8 # [0,1]
exposedField SFColor emissiveColor 0 0 0 # [0,1]
exposedField SFFloat shininess 0.2 # [0,1]
exposedField SFColor specularColor 0 0 0 # [0,1]
exposedField SFFloat transparency 0 # [0,1]
}

materialBean

transparency maps to TransparencyAttributes node (see diagram below)

other parameter map directly to Material node

sffloat_m ambientIntensity;
sfcolor_m diffuseColor;
sfcolor_m emissiveColor;
sffloat_m shininess;
sfcolor_m specularColor;
sfcolor_m ambientColour;
sfbool_m lightingEnable
Color3f ambientColor
Color3f diffuseColor
Color3f emissiveColor
boolean lightingEnable
float shininess
Color3f specularColor
Color3f ambientColor
MovieTexture MovieTexture {
exposedField SFBool loop FALSE
exposedField SFFloat speed 1.0 # (-,)
exposedField SFTime startTime 0 # (-,)
exposedField SFTime stopTime 0 # (-,)
exposedField MFString url []
field SFBool repeatS TRUE
field SFBool repeatT TRUE
eventOut SFTime duration_changed
eventOut SFBool isActive
}

Texture node

ImageTexture,MovieTexture and PixelTexture all map to Texture node

   

Morph

Appearance appearance
boolean appearanceOverrideEnable
GeometryArray geometryArray
double[] weights
Retrieves the Morph node's morph weight vector.

NavigationInfo NavigationInfo {
eventIn SFBool set_bind
exposedField MFFloat avatarSize [0.25, 1.6, 0.75] # [0,)
exposedField SFBool headlight TRUE
exposedField SFFloat speed 1.0 # [0,)
exposedField MFString type ["WALK", "ANY"]
exposedField SFFloat visibilityLimit 0.0 # [0,)
eventOut SFBool isBound
}
navigationInfoBean sfbool_m set_bind;
mffloat_m avatarSize;
sfbool_m headlight;
sffloat_m speed;
mfstring_m type;
sffloat_m visibilityLimit;
sfbool_m isBound;
Normal Normal {
exposedField MFVec3f vector [] # (-,)
}
normalBean mfvec3f_m normal
NormalInterpolator NormalInterpolator {
eventIn SFFloat set_fraction # (-,)
exposedField MFFloat key [] # (-,)
exposedField MFVec3f keyValue [] # (-,)
eventOut MFVec3f value_changed
}
normalInterpolatorBean sffloat_m set_fraction;
mffloat_m key;
mfvec3f_m keyValue;
sfvec3f_m value_changed;
   

OrderedGroup

SceneGraphPath[] children

   

OrientedShape3D

Geometry geometry,
Appearance appearance,
int mode,
Vector3f axis
Point3f point

OrientationInterpolator OrientationInterpolator {
eventIn SFFloat set_fraction # (-,)
exposedField MFFloat key [] # (-,)
exposedField MFRotation keyValue [] # [-1,1],(-,)
eventOut SFRotation value_changed
}
orientationInterpolatorBean sffloat_m set_fraction;
mffloat_m key;
mfrotation_m keyValue;
sfrotation_m value_changed;
PixelTexture PixelTexture {
exposedField SFImage image 0 0 0 # see 5.5, SFImage
field SFBool repeatS TRUE
field SFBool repeatT TRUE
}

Texture node

ImageTexture,MovieTexture and PixelTexture all map to Texture node

PlaneSensor PlaneSensor {
exposedField SFBool autoOffset TRUE
exposedField SFBool enabled TRUE
exposedField SFVec2f maxPosition -1 -1 # (-,)
exposedField SFVec2f minPosition 0 0 # (-,)
exposedField SFVec3f offset 0 0 0 # (-,)
eventOut SFBool isActive
eventOut SFVec3f trackPoint_changed
eventOut SFVec3f translation_changed
}
planeSensorBean sfbool_m autoOffset;
sfbool_m enabled;
sfvec2f_m maxPosition;
sfvec2f_m minPosition;
sfvec3f_m offset;
sfbool_m isActive;
sfvec3f_m trackPoint_changed;
sfvec3f_m translation_changed;
   

PointSound inherits from sound plus:

MediaContainer soundData,
float initialGain,
int loopCount,
boolean release,
boolean continuous,
boolean enable,
Bounds region,
float priority,
Point3f position,
float[] attenuationDistance,
float[] attenuationGain
Point2f[] distanceGain

PointLight PointLight {
exposedField SFFloat ambientIntensity 0 # [0,1]
exposedField SFVec3f attenuation 1 0 0 # [0,)
exposedField SFColor color 1 1 1 # [0,1]
exposedField SFFloat intensity 1 # [0,1]
exposedField SFVec3f location 0 0 0 # (-,)
exposedField SFBool on TRUE
exposedField SFFloat radius 100 # [0,)
}
pointLightBean extends lightBean sfvec3f_m attenuation;
sfvec3f_m position;
sffloat_m radius

PointLight

boolean lightOn,
Color3f color,
Point3f position,
Point3f attenuation

PointSet PointSet {
exposedField SFNode color NULL
exposedField SFNode coord NULL
}
pointSetBean extends geometryBean
PositionInterpolator PositionInterpolator {
eventIn SFFloat set_fraction # (-,)
exposedField MFFloat key [] # (-,)
exposedField MFVec3f keyValue [] # (-,)
eventOut SFVec3f value_changed
}
positionInterpolatorBean sffloat_m set_fraction;
mffloat_m key;
mfvec3f_m keyValue;
sfvec3f_m value_changed;

PositionInterpolator

Alpha alpha
TransformGroup target
Transform3D axisOfTranslation
float startPosition
float endPosition

   

PositionPathInterpolator

Alpha alpha,
TransformGroup target,
Transform3D axisOfTranslation,
float[] knots,
Point3f[] positions

ProximitySensor PositionInterpolator {
eventIn SFFloat set_fraction # (-,)
exposedField MFFloat key [] # (-,)
exposedField MFVec3f keyValue [] # (-,)
eventOut SFVec3f value_changed
}
proximitySensorBean sfvec3f_m center;
sfvec3f_m size;
sfbool_m enabled;
sfbool_m isActive;
sfvec3f_m position_changed;
sfrotation_m orientation_changed;
sftime_m enterTime;
sftime_m exitTime;
   

Raster

Point3f pos,
int type, java.awt.
Point offset, java.awt.
Dimension size,
ImageComponent2D image,
DepthComponent depthComponent

   

RotationInterpolator

Alpha alpha,
TransformGroup target,
Transform3D axisOfRotation,
float minimumAngle,
float maximumAngle

   

RotationPathInterpolator

Alpha alpha,
TransformGroup target,
Transform3D axisOfRotation,
float[] knots,
Quat4f[] quats

   

RotPosPathInterpolator

Alpha alpha,
TransformGroup target,
Transform3D axisOfRotPos,
float[] knots,
Quat4f[] quats,
Point3f[] positions

ScalarInterpolator ScalarInterpolator {
eventIn SFFloat set_fraction # (-,)
exposedField MFFloat key [] # (-,)
exposedField MFFloat keyValue [] # (-,)
eventOut SFFloat value_changed
}
scalarInterpolatorBean sffloat_m set_fraction;
mffloat_m key;
mffloat_m keyValue;
sffloat_m value_changed;

ScaleInterpolator

Alpha alpha,
TransformGroup target,
Transform3D axisOfScale
float minimumScale
float maximumScale

Script Script {
exposedField MFString url []
field SFBool directOutput FALSE
field SFBool mustEvaluate FALSE
# And any number of:
eventIn eventType eventName
field fieldType fieldName initialValue
eventOut eventType eventName
}
scriptBean mfstring_m url;
sfbool_m directOutput;
sfbool_m mustEvaluate;
mfparam events;
Shape Shape {
exposedField SFNode appearance NULL
exposedField SFNode geometry NULL
}
shape3dBean

Shape3D

Geometry[] geometry
Appearance appearance

   

SharedGroup

SceneGraphPath[] children

Sound Sound {
exposedField SFVec3f direction 0 0 1 # (-,)
exposedField SFFloat intensity 1 # [0,1]
exposedField SFVec3f location 0 0 0 # (-,)
exposedField SFFloat maxBack 10 # [0,)
exposedField SFFloat maxFront 10 # [0,)
exposedField SFFloat minBack 1 # [0,)
exposedField SFFloat minFront 1 # [0,)
exposedField SFFloat priority 0 # [0,1]
exposedField SFNode source NULL
field SFBool spatialize TRUE
}
soundBean sfstring_m description;
sfbool_m loop;
sffloat_m pitch;
sftime_m startTime;
sftime_m stopTime;
mfstring_m url;
sftime_m duration_changed;
sfbool_m isActive;

Sound

MediaContainer soundData,
float initialGain,
int loopCount,
boolean release,
boolean continuous,
boolean enable,
Bounds region,
float priority

     

Soundscape

Bounds region,
AuralAttributes attributes

Sphere Sphere {
field SFFloat radius 1 # (0,)
}

sphereBean extends geometryBean

geometry nodes hold VRML parameters + conversion to IFS arrays

sffloat_m radius
SphereSensor SphereSensor {
exposedField SFBool autoOffset TRUE
exposedField SFBool enabled TRUE
exposedField SFRotation offset 0 1 0 0 # [-1,1],(-,)
eventOut SFBool isActive
eventOut SFRotation rotation_changed
eventOut SFVec3f trackPoint_changed
}
sphereSensorBean sfbool_m autoOffset;
sfbool_m enabled;
sffloat_m offset;
sfbool_m isActive;
sfrotation_m rotation_changed;
sfvec3f_m trackPoint_changed;
SpotLight SpotLight {
exposedField SFFloat ambientIntensity 0 # [0,1]
exposedField SFVec3f attenuation 1 0 0 # [0,)
exposedField SFFloat beamWidth 1.570796 # (0,/2]
exposedField SFColor color 1 1 1 # [0,1]
exposedField SFFloat cutOffAngle 0.785398 # (0,/2]
exposedField SFVec3f direction 0 0 -1 # (-,)
exposedField SFFloat intensity 1 # [0,1]
exposedField SFVec3f location 0 0 0 # (-,)
exposedField SFBool on TRUE
exposedField SFFloat radius 100 # [0,)
}
spotLightBean extends pointLightBean sffloat_m spreadAngle;
sffloat_m concentration;
sfvec3f_m direction;

SpotLight

Color3f color,
Point3f position,
Point3f attenuation
Vector3f direction
float spreadAngle
float concentration

Switch Switch {
exposedField MFNode choice []
exposedField SFInt32 whichChoice -1 # [-1,)
}
switchBean extends groupBean sfint32_m whichChoice

Switch

SceneGraphPath[] children
int whichChild

     

SwitchValueInterpolator

Alpha alpha
Switch target
int firstChildIndex
int lastChildIndex

Text Text {
exposedField MFString string []
exposedField SFNode fontStyle NULL
exposedField MFFloat length [] # [0,)
exposedField SFFloat maxExtent 0.0 # [0,)
}

textBean extends geometryBean

geometry nodes hold VRML parameters + conversion to IFS arrays

mfstring_m string;
mffloat_m length;
sffloat_m maxExtent

Text3D

Font3D font3D, java.lang.
String string,
Point3f position,
int alignment,
int path

   

Texture

int mipMapMode
int format
int width
int height
void
Color4f boundaryColor
int boundaryModeS
int getBoundaryModeT
boolean enable
int format
int height
ImageComponent[] images
int magFilter
int minFilter
int numMipMapLevels

   

Texture2D

int mipmapMode
int format
int width
int height

   

Texture3D

int mipmapMode,
int format,
int width,
int height,
int depth

TextureCoordinate TextureCoordinate {
exposedField MFVec2f point [] # (-,)
}
textureCoordinateBean mfvec2f_m texCoord
TextureTransform TextureTransform {
exposedField SFVec2f center 0 0 # (-,)
exposedField SFFloat rotation 0 # (-,)
exposedField SFVec2f scale 1 1 # (-,)
exposedField SFVec2f translation 0 0 # (-,)
}
textureTransformBean sfvec2f_m center;
sffloat_m rotation;
sfvec2f_m scale;
sfvec2f_m translation;
TimeSensor TimeSensor {
exposedField SFTime cycleInterval 1 # (0,)
exposedField SFBool enabled TRUE
exposedField SFBool loop FALSE
exposedField SFTime startTime 0 # (-,)
exposedField SFTime stopTime 0 # (-,)
eventOut SFTime cycleTime
eventOut SFFloat fraction_changed # [0, 1]
eventOut SFBool isActive
eventOut SFTime time
}
timeSensorBean sftime_m cycleInterval;
sfbool_m enabled;
sfbool_m loop;
sftime_m startTime;
sftime_m stopTime;
sftime_m cycleTime;
sffloat_m fraction_changed;
sfbool_m isActive;
sftime_m time
TouchSensor TouchSensor {
exposedField SFBool enabled TRUE
eventOut SFVec3f hitNormal_changed
eventOut SFVec3f hitPoint_changed
eventOut SFVec2f hitTexCoord_changed
eventOut SFBool isActive
eventOut SFBool isOver
eventOut SFTime touchTime
}
touchSensorBean sfbool_m enabled;
sfvec3f_m hitNormal_changed;
sfvec3f_m hitPoint_changed;
sfvec2f_m hitTexCoord_changed;
sfbool_m isActive;
sfbool_m isOver;
sftime_m touchTime;
Transform Transform {
eventIn MFNode addChildren
eventIn MFNode removeChildren
exposedField SFVec3f center 0 0 0 # (-,)
exposedField MFNode children []
exposedField SFRotation rotation 0 0 1 0 # [-1,1],(-,)
exposedField SFVec3f scale 1 1 1 # (0,)
exposedField SFRotation scaleOrientation 0 0 1 0 # [-1,1],(-,)
exposedField SFVec3f translation 0 0 0 # (-,)
field SFVec3f bboxCenter 0 0 0 # (-,)
field SFVec3f bboxSize -1 -1 -1 # (0,) or -1,-1,-1
}
transformGroupBean extends groupBean sfvec3f_m center = null;
sfrotation_m rotation = null;
sfvec3f_m scale = null;
sfrotation_m scaleOrientation = null;
sfvec3f_m translation = null;
sfvec3f_m bboxCenter = null;
sfvec3f_m bboxSize

TransformGroup

SceneGraphPath[] children
Transform3D t1

where Transform3D contains:Matrix4f chich can be constructed and set with quaternion, translation, and scale values.

   

TransparencyInterpolator

Alpha alpha,
TransparencyAttributes target
float minimumTransparency
float maximumTransparency

Viewpoint Viewpoint {
eventIn SFBool set_bind
exposedField SFFloat fieldOfView 0.785398 # (0,)
exposedField SFBool jump TRUE
exposedField SFRotation orientation 0 0 1 0 # [-1,1],(-,)
exposedField SFVec3f position 0 0 10 # (-,)
field SFString description ""
eventOut SFTime bindTime
eventOut SFBool isBound
}
viewPlatformBean extends transformGroupBean sfbool_m set_bind;
sffloat_m fieldOfView;
sfbool_m jump;
sfrotation_m orientation;
sfvec3f_m position;
sfstring_m description;
sftime_m bindTime;
sfbool_m isbound

ViewPlatform

float activationRadius
int viewAttachPolicy

VisibilitySensor VisibilitySensor {
exposedField SFVec3f center 0 0 0 # (-,)
exposedField SFBool enabled TRUE
exposedField SFVec3f size 0 0 0 # [0,)
eventOut SFTime enterTime
eventOut SFTime exitTime
eventOut SFBool isActive
}
visibilitySensorBean sfvec3f_m center;
sfbool_m enabled;
sfvec3f_m size;
sftime_m enterTime;
sftime_m exitTime;
sfbool_m isActive
WorldInfo WorldInfo {
field MFString info []
field SFString title ""
}
worldInfoBean mfstring_m info;
sfstring_m title

 


Apperance

The java Scene graph structure and the VRML file structure differ in the area of the Apperance node.

VRML just has Material, Texture and TextureTransform nodes but Java3D has a number of Attribute nodes which contain some information, such as transparency from the VRML Material node.


metadata block
see also:

 

Correspondence about this page

Book Shop - Further reading.

Where I can, I have put links to Amazon for books that are relevant to the subject, click on the appropriate country flag to get more details of the book or to buy it from them.

cover This book introduces 3D concepts, VRML, Java3D, MPEG4/BIFS, and X3D. It is a very good introduction to the theory, The writers have an in depth knowledge due to their involvement in the standards making. This is a good book to help you choose which 3D open standards to use and to give you a good insight into these standards. It is probably not for those who want a basic introduction to 3D or for these who want a step-by-step programming in 3D book.

cover Covers VRML 2 (but not the upcoming X3D standard). A good introduction to all VRML2 node types and how to build them.

Commercial Software Shop

Where I can, I have put links to Amazon for commercial software, not directly related to this site, but related to the subject being discussed, click on the appropriate country flag to get more details of the software or to buy it from them.

 

This site may have errors. Don't use for critical systems.

Copyright (c) 1998-2017 Martin John Baker - All rights reserved - privacy policy.