| Home >> All >> com >> trapezium >> [ vrml Javadoc ] |
• com.trapezium.vrml: Javadoc index of package com.trapezium.vrml.
Package Samples:
• com.trapezium.vrml.fields
• com.trapezium.vrml.grammar
• com.trapezium.vrml.node
• com.trapezium.vrml.node.generated
• com.trapezium.vrml.node.humanoid
• com.trapezium.vrml.node.space
• com.trapezium.vrml.visitor
Classes:
• SpaceStructure: The SpaceStructure keeps track of vertices, edges, and faces in a somewhat fluid manner. There are three sets of objects, corresponding to vertices, edges, and faces, but these sets can be mixed, and relationships created between these sets. This is done to allow transformations of one type into another. A SpaceEntitySet represents a set of SpacePrimitive objects used by a particular space structure. The Strategy field "primitiveHandler" indicates the current visualization of a space entity and its surrounding entities. Relationships between the sets are created as needed, only r1 is known at the ...
• IndexInfo: Tracks association between index, perVertex, and value fields. The IndexInfo is used to track associates between related fields. The technique used repeatedly in the VRML 2.0 spec is centered on coord and coordIndex. The coord is a Node, coordIndex is not. This means coord values can be DEFfed and USEd, but index values cannot. The second technique is associations between coord and texCoord, color, and normal fields. This assocation is implicit in the data. If the texCoord, color, or normal nodes exist, and there is no texCoordIndex, colorIndex, normalIndex, then these three nodes (texCoord, color, ...
• VRML97parser: Main class for parsing a VRML 2.0 file. A Scene is the root of a VRML element hierarchy. This is a simple hierarchy where each VrmlElement may or may not have children. Much of the additional functionality required is implemented by using the "Visitor Pattern" on this hierarchy. This pattern encapsulates features in the visitor objects. Within the SceneRule factory, the above parameters eventually turn into a Token enumerator, and the Scene is constructed as follows: TokenEnumerator tokenEnumerator = ... Scene scene = new Scene( fileUrl, tokenEnumerator ); VRML97parser parser = new VRML97parser(); ...
• PROTORule: Creates the scene graph component for a PROTO declaration. Grammar handled by "Build" method: proto ::= PROTO nodeTypeId [ interfaceDeclarations ] { protoBody } ; interfaceDeclarations ::= interfaceDeclaration | interfaceDeclaration interfaceDeclarations | empty ; protoBody ::= protoStatements node statements ; protoStatements ::= protoStatement | protoStatement protoStatements | empty ; Note: the implementation of the "protoBody" portion of above grammar is done through the SceneRule, followed by a check that the body consists of at least one node. This check (and possible error mark) is done ...
• PROTOcollector: The PROTOcollector resolves conflicts introduced when one scene graph is merged into another. It collects infomation about all conflicts, then provides information about those conflicts. The method "resolveConflicts" resolves those which can be handled in-place. Otherwise, it has methods for extracting the information token by token. In-place conflict resolution handles DEF/USE/PROTO naming conflicts, but does not handle moving PROTOs to new locations in the file. Conflict resolution is one of two ways: the DEFNameFactory in the destination scene is used if it exists, otherwise an algorithm of ...
• VrmlElement: A VrmlElement is the base class for any object in the VRML 2.0 object hierarchy. Specific subclasses get created as a ".wrl" file is parsed. The grammar determines which type of element to create during parsing. Each VrmlElement contains zero or more children, which are also VrmlElement. The object hierarchy for this is very simple. The root level object is a Scene, with children that are Nodes or ROUTEs. Node children are fields. This object hierarchy parallels the VRML syntax. The VrmlElement implements the visitor pattern, which allows the object structure to be traversed after it is created. ...
• Scene: Scene graph component representing an entire VRML file, or the body of a PROTO. The only difference between the PROTO body and a Scene is that the PROTO body is required to have at least one node. This restriction is not part of the Scene, and is a check performed by the grammar package during parsing. The Scene has a single Declaration for each child element. The Scene gives the name scope for PROTO and DEF nodes. As a file is processed, any PROTO and DEF nodes are registered with the Scene. Name uniqueness is forced during this registration by appending "_1", "_2", etc.
• NodeStatementRule: Creates the scene graph component for a node This is the only part of the grammar other than the VRML97parser that is publicly accessible. This is necessary because SFNodeValue and MFNodeValue in the com.trapezium.vrml.fields package use an instance of this to create node scene graph components. Grammar handled by "Build" method: nodeStatement ::= node | DEF nodeNameId node | USE nodeNameId ; The portion "DEF nodeNameId node" is handled by DEFRule.java The portion "USE nodeNameId" is handled by USERule.java
• ComplexityData: Information related to complexity of a scene graph. This is used to accumulate error and polygon count information during the processing of files. The ComplexityVisitor contains a ComplexityData element where it stores its information. If several files are being processed, a single global ComplexityData object is used to contain the sum of their information. Each time a ComplexityVisitor completes its traversal of the scene graph, it updates the global ComplexityData with the data from that single traversal (see the "addInfo" method).
• SpecNodeRule: Process the file we are using to generate built in node classes. This is similar, but not identical to ".wrl" file processing. The "Spec" object is built as follows: Spec s = new Spec(); SpecRule.Build( v, s ); The spec grammar is: spec: specNode specNode: Category categoryName { interfaceDeclarations* } nodeType { interfaceDeclarations* } When the "Spec" object has been created, we create a visitor to visit each node, and generate code based on the interfaceDeclarations and the embedded controls (tips, etc.)
• ScriptGutRule: Creates the scene graph component for the internals of a Script node. This is much different than other built in nodes because Script nodes allow user defined interface (field) extensions. Grammar handled by "Build" method: scriptGut: nodeGut restrictedInterfaceDeclaration eventIn fieldType eventInId IS eventInId eventOut fieldType eventOutId IS eventOutId field fieldType fieldId IS fieldId
• InterfaceDeclarationRule: Creates an interface field scene graph component. The "interfaceDeclaration" handles exposedField, field, eventIn, and eventOut interface declarations. field, eventIn, and eventOut declarations are handled by the RestrictedInterfaceDeclarationRule. Grammar handled by "Build" method: interfaceDeclaration: restrictedInterfaceDeclaration exposedField fieldType fieldId fieldValue
• PROTONodeRule: Creates the scene graph component for a PROTO instance. Grammar handled by "Build" method: protoNodeTypeId { nodeGuts } Note: the PROTOInstance "copyBaseNodeInfo" method does not copy all nodes in the PROTO declaration body, and substitute values as indicated by IS. When this is done, PROTO checking can be done for PROTO interface fields passed through IS.
• PROTOInstance: Scene graph component for a PROTO instance. The PROTOInstance has field values which are explicitly declared, and are part of the PROTO interface. It has node values which are copied from the PROTO declaration, with actual values from the instance substituted where indicated by IS fields. Note: The above level of PROTOInstance construction is not complete. USE nodeNameId
• Spec: The scene graph component for a Spec node. Spec nodes were used to generate source files in package com.trapezium.vrml.node.generated. Re-architecture due to OutOfMemory problem made generated nodes much less complex, probably should eliminate these eventually. Note: spec nodes & code generation no longer works. Probably need to drop this altogether.
• SpaceStructureLoader: The SpaceStructureLoader manages a set of SpaceStructures associated with IndexedFaceSets in a file. Two sets of SpaceStructures are kept -- one for each IFS in the file, accessed by index, and one for each Coordinate node in the file, accessed by coord node. These lists will be different if the file uses DEF/USE of Coordinate nodes.
• SpacePrimitive: The SpacePrimitive is either a Vertex, Edge, or Face, but does not know its own type. The SpaceEntitySet contains a set of SpacePrimitives, and a Strategy for viewing those primitives. The Strategy determines whether the primitive is a Vertex, Edge, or Face, as well as the actual types of the SpacePrimitives in the surrounding ccwVec.
• MFFieldValue: MFFieldValue is the base class for all multiple value fields, which have the following syntax: 1. an optional "[" 2. zero or more SFFieldValues of the specified type 3. an optional "]" The individual fields are added as children of this element. Individual fields are created by the "subclassFactory" template method.
• NotExposedField: Scene graph component for a "field" instance or declaration. Note this is a little confusing: field === NotExposedField exposedField === ExposedField eventIn === EventIn eventOut === EventOut The Field.java class is the base class for NotExposedField, ExposedField, EventIn, and EventOut.
• ElevationGridVerifier: Verifies information in ElevationGrid node. Verifies that "xDimension" and "zDimension" are both specified, and have values at least 2. Verifies that the number of "height" values is correct given the "xDimension" and "zDimension". Verifies that the number of colors, normals, textures if present is correct.
• BuiltInNodeRule: Creates built in VRML node scene graph components. Grammar handled by "Build" method: builtInNodeTypeId { builtInNodeGuts } Grammar handled by "BuildNodeGuts" method: builtInNodeGuts ::= nodeBodyElement | nodeBodyElement nodeBody | empty ;
• FieldId: Scene graph component representing a field id. Also includes all built in fieldId names (these should probably move to VRML97 in grammar package). FieldId optimization is to no longer create these as scene graph component, but set them in a Field object. This optimization is not complete.
• DEFRule: Creates a DEF node scene graph component. Grammar handled by "Build" method: DEF nodeNameId node After the node is created, its name is registered in the Scene. If any other node is registered with that same name, both are marked with "duplicate DEF" warnings.
• BboxSizeSFVec3fValue: Scene graph component for sequence of positive or all -1 vec3f values, convention used only for bboxSize fields. There is no corresponding VRML97 data type for this case, however, the VRML specification does require this as a data type for some fields (e.g. scale).
• StatementRule: Creates the scene graph component for a node, PROTO, or ROUTE. Grammar handled by "Build" method: statement ::= nodeStatement | protoStatement | routeStatement ; protoStatement ::= proto | externproto ;
| Home | Contact Us | Privacy Policy | Terms of Service |