Function-based Time-dependent Shape Modeling on the Web

Transcription

1 Function-based Time-dependent Shape Modeling on the Web Qi Liu and Alexei Sourin Nanyang Technological University, Singapore Abstract In this paper we propose FVRML a function-based extension of Virtual Reality Modeling Language which allows for time-dependent shape modeling on the web. Shape s geometry, 3D texture, color and transformations can be defined with analytical functions typed straight in VRML code. These analytical functions can be functions of time. FVRML allows us to greatly extend the abilities of VRML with a very intuitive approach to shape modeling based on using analytical functions. Several functions can be combined into one using Java scripts emulated in FVRML, which allows for even greater flexibility and convenience of shape modeling. 1. Introduction Visual cyberworlds require computer generated objects to appear and feel like real objects, which assumes animated shape transformations to be an intrinsic part of each shared virtual environment. However only limited and polygon-based shape animation can be found there, specifically when using Virtual Reality Modeling Language (VRML) [1]. This greatly limits the expressive power of VRML and motivates our research in this direction. In this paper, we propose a hybrid approach to time-dependent shape modeling based on concurrent using implicit, explicit and parametric functions defining the shape s geometry, appearance and transformation through time. 1.1 Time-dependent web visualization with Virtual Reality Modeling Language Virtual Reality Modeling Language is an international standard file format widely used in creating and exchanging 3D objects and virtual worlds, as well as other multimedia and interactive elements such as video and audio clips, hyperlinks, sensors, etc. The basic elements of VRML are nodes, which are abstractions of various objects and concepts in real worlds. Different nodes can produce different events, which can be exchanged between the nodes and used as triggers for various purposes. By properly compositing these nodes, the virtual environment created by VRML can be animated following the user s interaction. In addition to interactions, standard VRML97 provides three time-dependent nodes, which allow for creating virtual environments dynamically changing through time. The time-dependent nodes are AudioClip, MovieTexture and TimeSensor. Based on their properties, we can classify them into two groups, Self-contained Time-dependent Nodes and Nonself-contained Time-dependent Nodes. Self-contained Time-dependent Nodes can be used independently of any additional nodes. These nodes always contain internal time sensing mechanisms which allow them to track changes of time. Usually, the selfcontained time-dependent nodes expose only a few parameters and events to other nodes. By changing these parameters, default behavior can be changed accordingly. In VRML97, AudioClip and MovieTexture belong to this group. Non-self-contained Time-dependent Nodes cannot be used on their own, and therefore they expose as much properties and events as possible for the sake of flexibility. TimeSensor is such a node. Combining the TimeSensor and various interpolators provided by VRML97, time-dependent objects can be modeled in two ways: either by time-dependent transformations of a static object, or by time-dependent morphing between several objects. This allows for only simple animation to be done. Time-dependent morphing proposed in [2] can achieve more sophisticated shape transformations. However, it requires using VRML s CoordinateInterpolator for each pair of objects which results in a very large file size even for simple objects. In order to reduce the file size, three morphing nodes were proposed to simplify the definition of the interpolation [3]. VectorInterpolator node, which interpolates a set of vectors linearly, can replace a set of interpolators. CoodinateMorpher node, and NormalMorpher node, which calculate the coordinates and normals of a morphing object, can replace the

2 JavaScripts and make the morphing algorithm more transparent to authors. An alternative approach is to replace a set of complex models with several simple parameters and coordinates which also reduces the file size of time-dependent objects. In [4], human avatars are simplified into segments and joints. With compression and decompression method, humanoid animations can be even transmitted through telephone lines [5]. In addition to this, common human motions can be predefined with several parameters. For example, in [6], avatars in virtual worlds can have several JavaScript controlled predefined motions (e.g. walking, running, gesticulating). Certain parts of avatars (e.g. face), which require detailed motion, may have more controlling parameters [7, 8]. Such message-based time-dependent visualization can be used in dynamic model presentation system [9]. However, it requires pre-installation of all models before visualization, which is not practical if frequent changes of the models is expected. Visualization of time-dependent scientific data can be done with VRML. The examples are web visualization of oceanographic data [ 10 ] and molecular quantum dynamics [11]. However, these approaches are modeldependent and they cannot be generalized. In conclusion, the ability of defining time-dependent object in VRML is still very limited and there is a room for further research on this topic motivated by large sizes of animated VRML objects, limited set of animated transformations, and limited set of time-dependent models. 1.2 Standard time-dependent VRML nodes In the VRML97 specification, both self-contained and non-self-contained time-dependent nodes have some common features. They can be activated and deactivated at specified times. Exposed fields starttime, stoptime, and loop are used to determine when the nodes become active or inactive. By analyzing the behavior of time-dependent nodes in standard VRML, we can classify the execution approaches according to the start, stop, and cycle controls. Understanding these matters is important for a proper and consistent design of the time-dependent node, which is presented in this paper. Time-dependent nodes can be started: 1. At the time of entering the virtual world 2. With a delay relative to the time of entering the virtual world, and 3. By a certain event with or without delay. Termination of time-dependent nodes can be done: 1. After executing one cycle 2. After executing a number of cycles 3. After certain time regardless to cycles 4. Caused by a certain event, and 5. Never. Time-dependent nodes can repeat: 1. With gaps between cycles, and 2. Without gaps between cycles. 2. Function-based shape modeling in VRML The extension of VRML with function-based shape modeling was proposed by the authors in [12] following the preliminary works [ 13, 14 ]. The proposed hybrid function-based nodes (FShape, FGeometry, FMaterial, FTexture3D, FAppearance, FTransform) allow for extending VRML97 with practically any type of object s geometry and sophisticated graphics appearances by defining the object s geometry, appearance (color and 3D texture) and transformations with analytical formulas which are implicit, explicit and parametric representations used concurrently. In contrast to the polygon-based models of VRML, function-based nodes greatly reduce the size of the models and provide an unlimited level of detail. Also, these nodes allow for using set-theoretic as well as any analytically-defined geometric operations which can be introduced by the user. Two types of functions are used in these nodes. They are explicit FRep functions [15] and parametric functions. FRep functions incorporate implicit surface representations and volume representations by implicit and explicit functions: f(x,y,z)=0; g=f(x,y,z) 0. Parametric functions define surfaces and solids as: x= φ 1 (u,v,w); y= φ 2 (u,v,w); z= φ 3 (u,v,w); Geometry, 3D texture, and color are defined by FRep or parametric functions in their own domains and then merged together into one shape by the predefined mapping functions. First, geometric textures are mapped onto the original shape, and then colors are mapped to the textured shape to form the final textured colored shape. This process repeats as many times as needed. For example, we can define an original shape parametrically: x = (1 0.3sin 5v) cosv (4 + cosu) y = (1 0.3sin 5v) sin v (4 + cosu) z = sinu u = [ π, π ], v = [ π, π ] Then, we map to this shape the geometric texture which is Perlin noise displacement defined by the FRep function: g = 0.1(sin 2π xsin 2πy + sin 2πx sin 2πz + sin 2πy sin 2πz) Finally a parametrically-defined color is applied onto the textured shape by mapping the colored plane onto the shape: r = 1; g = sin u ; b = 0; With these two parametric and one FRep functions, the final shape is defined as it is shown in Figure 1.

3 Texture shape Figure 1. Modeling shape by consecutive definition of its geometry, texture and color Though very efficient, the developed function-based nodes have two limitations: 1. They do hot support time-dependent functions, and 2. Only single formula can be typed in function definitions. These problems are resolved in our work. 3. Time-dependent FVRML nodes Color shape 3.1 Time-dependent FVRML prototypes Based on the idea of employing analytical functions for defining time-dependent geometry, texture and color, the nodes proposed in [12] must be extended accordingly to constitute the new Function-based Extension of VRML (FVRML). In order to define time-dependent shapes, we introduce an additional argument representing the time. Therefore, to define time-dependent shapes four arguments of FRep or parametric functions are to be used. Since we do not want to impose any restrictions on mathematical functions which can be treated as functions of time, it appears feasible to allow for defining any range of the time parameter including negative real numbers. Eventually, this time domain will be somehow, e.g. linearly, mapped to the real time which is used in VRML s animation. In Section 1 we have identified several possible patterns of using time-dependent objects in VRML. The proposed FVRML extension must be consistent with them. Moreover, in order to ease its use, it appears feasible to allow the new nodes work in two modes: as selfcontained nodes for novice users, and as nodes communicating with TimeSensors for more advance applications. While in VRML cycletime is missing in the self-contained nodes, we will include this field in our prototypes. The proposed prototypes are shown in Appendix. The time-related events and fields are typed in bold. In this prototype, timespan defines the range of the time used in visualization. Event set_fraction is designed to communicate with an external TimeSensor whose fraction_changed event will be routed. Other fields and events are designed to be consistent with the VRML97 TimeSensor. Since the fields and events provided by TimeSensor are exposed, all time-controlled cases considered in Section 1.3, including three start controls, five stop controls and two cycle controls, can be easily implemented following either the self-contained schemes or the schemes for TimeSensor node. 3.2 Function scripts Defining complex shapes, appearances and operations usually assumes using multiple formulas and temporary variables. This requires a script-like mathematical language. To be consistent with VRML97, which has a JavaScript as a standard feature, and to ease the learning curve, we emulated in the FVRML a subset of JavaScipt. In this JavaScript emulation, all variables, arrays and constants have only one type float. The following mathematical functions are implemented: abs(x), sqrt(x), exp(x), log(x), sin(x), cos(x), tan(x), acos(x), asin(x), atan(x), ceil(x), floor(x), round(x), max(x,y), min(x,y), atan2(y,x), mod(x,y), cosh(x), sinh(x), tanh(x), log10(x). We also introduced three operators &, and ^, which represent intersection, union, and power operations, respectively. Custom functions can be defined in the same way as defining a function in JavaScript. Recursions are allowed. There are also the following flow control operators: for-loops, while-loops, do-while-loops, break, continue, and if-else. The script is compiled into intermediate codes when it is loaded or changed. The intermediate codes are executed by a virtual machine whenever evaluation is required. If a function named FRep with three or four arguments exists in the script, the script is recognized as a definition of FRep function. Otherwise, functions named parametric_x, parametric_y, and parametric_z (for shapes and geometric textures), or parametric_r, parametric_g, and parametric_b (for colors) must be used to define parametric functions. If all these four functions exist concurrently, FRep function will have priority.

4 3.3 Examples of shape metamorphoses With the proposed FVRML prototypes and scripts, animated shape metamorphoses can be easily defined as time-dependent transformations of shape s geometry, 3D texture and color. We will illustrate these transformations using a linear function interpolation: f( abc,, ) = f1( abc,, )(1 t) + f2( abct,, ) where parameter t is in the range [0, 1]. In this formula, function f 1 defines the initial shape s geometry, texture or color, while function f 2 represents the final shape s geometry, texture or color, respectively. For FRep functions, arguments a,b,c are Cartesian coordinates, and only one such a morphing function is needed. For parametric functions, arguments a,b,c are coordinates in parametric domain, and three morphing functions are needed to define Cartesian coordinates x,y,z, respectively. In Figure 2, three snapshots of geometric morphing from the snail-like shape to the star-like shape are shown. The FVRML code of this morphing transformation is shown in Listing 1. Both, the initial and final shapes are defined in FVRML parametrically inside the function script. The time-dependent shape is defined as a linear interpolation between the initial and final shapes. The internal timer of the FShape node is used for defining an infinite looping with period 5 sec, while the time within the script is changing in the range [0, 1]. Besides geometric morphing, FVRML is also capable of defining concurrent metamorphoses of geometric textures and colors. In Figure 3, the geometric texture is being grown on the initial shape as a time-dependent process. The texture is defined by a time-dependent displacement which value is controlled by Perlin noise function as it was illustrated in Section 2. The swing animation combining into an infinite loop the growth of texture and the reverse process is defined in the FVML code shown in Listing 2. In this code, both internal and external time sensors are used to define a gap between two cycles. The internal timer defines a single 5 sec execution of the node. The external timer defines an infinite looping with 7 sec duration of each cycle. Thus there will be a 2 sec time gap between each cycle. Note that in this example the explicitly defined time-dependent geometric texture is mapped onto the parametrically defined geometric shape and the resulting shape is colored by the explicit functions. In Figure 4, we show four snapshots of the timedependent color metamorphoses on a surface of the function-defined shape. In this case, the shape remains static, but the colors on the shape are permuting in a fancy way. The FVRML code of this color transformation is shown in Listing 3. In this code the external time sensor is used in place of the internal one. Figure 2. Geometric morphing #VRML V2.0 utf8 FVRML PROTOs are omitted to save space FShape { enabled TRUE cycleinterval 5 loop TRUE Infinite looping with period 5 sec is defined diffusecolor "sin(sqrt(x*x+y*y+z*z) * pi)" patterncolor [ ] patternkey [-1 1] type "analytical" } } geometry FGeometry { resolution [50 50] parameters [ ] definition " Fancy color is defined by an explicit function function snail_x(u,v,w) { return 0.03*pi*v*(10+5*cos(pi*u))*cos(3*pi*v); } function snail_y(u,v,w) { return 0.03*pi*v*(10+5*cos(pi*u))*sin(3*pi*v); } function snail_z(u,v,w) { return 0.03*pi*v*(6+5*sin(pi*u)); } Final shape function star_x(u,v,w) { return ( *sin(v*5*pi))*cos(v*pi)*(4+cos(u*pi)); } function star_y(u,v,w) { return ( *sin(v*5*pi))*sin(v*pi)*(4+cos(u*pi)); } function star_z(u,v,w) { return 0.2*sin(u*pi); } Initial shape Morphing as a function of time function parametric_x(u,v,w,t) { return snail_x(u,v,w)*(1-t)+star_x(u,v,w)*t; } function parametric_y(u,v,w,t) { return snail_y(u,v,w)*(1-t)+star_y(u,v,w)*t; } function parametric_z(u,v,w,t) { return snail_z(u,v,w)*(1-t)+star_z(u,v,w)*t; }" type "script" } } Listing 1. FVRML code of the time-dependent shape morphing shown in Figure 1.

5 Figure 3. Growing texture #VRML V2.0 utf8 FVRML PROTOs are omitted to save space DEF shape FShape { cycleinterval 5 loop FALSE 5 sec duration and a single execution of the cycle are defined diffusecolor "r=1;g=fabs(sin(u));b=0;" type "analytical" } Time span used in texture3d FTexture3D { the texture function timespan definition "fabs(t-0.2)*(sin(2*pi*x)*sin(2*pi*y)+ sin(2*pi*x)*sin(2*pi*z)+sin(2*pi*y)*sin(2*pi*z))" type "displacement" } } geometry FGeometry { resolution [50 50] parameters [ ] 3D texture is defined with an explicit function definition "x=(1-0.3*sin(v*5*pi))*cos(v*pi)*(4+cos(u*pi)); y=(1-0.3*sin(v*5*pi))*sin(v*pi)*(4+cos(u*pi)); z=sin(u*pi);" type "analytical" } } DEF Time TimeSensor { loop TRUE cycleinterval 7 } Infinite looping and 7 sec period are defined with TimeSensor ROUTE Time.cycleTime TO shape.starttime Figure 4. Animated color permutations #VRML V2.0 utf8 FVRML PROTOs are omitted to save space DEF shape FShape { enabled FALSE } Internal timer is disabled timespan diffusecolor "sin(sqrt(x*x+y*y+z*z) * pi + t)" patterncolor [ ] patternkey [-1 1] type "analytical" } } Time-dependent color is defined explicitly geometry DEF geo FGeometry { resolution [ ] parameters [ ] definition " x=(0.3*sin(10*(u*pi+v*pi))+1)*cos(u*pi); y=(0.3*sin(10*(u*pi+v*pi))+1)*sin(u*pi)*cos(v*pi); z=(0.3*sin(10*(u*pi+v*pi))+1)*sin(u*pi)*sin(v*pi);" type "analytical" } DEF Time TimeSensor { cycleinterval 5 loop TRUE } Infinite looping with 5 sec period is defined with external ROUTE Time.fraction_changed TO shape.set_fraction Listing 2. FVRML code defining the process of growing 3D texture Listing 3. FVRML code defining dynamic color permutations

6 FVRML allows for defining operations with analytical functions. Therefore, the linear morphing used in the previous examples can be defined as a custom-defined operator to make programming even easier. For example, the geometric morphing defined in Listing 1 can be also defined as it is done in Listing 4. In this example we also illustrate a concurrent definition of time-dependent transformations of geometry and color. 3D texture also can be transformed concurrently with geometry and color. FTransform { cycleinterval 10 loop TRUE timespan 0 1 operation "f*(1-t)+g*t" type "analytical" polygonizer "analytical" parameters [ ] children [ } Morphing transformations defined analytically Time-dependent color FShape { timespan diffusecolor "sin(sqrt(x*x+y*y+z*z) * pi + t)" patterncolor [ ] patternkey [-1 1] type "analytical" } } geometry FGeometry { resolution [ ] definition " function parametric_x(u,v,w) Initial shape {return 0.03*pi*v*(10+5*cos(pi*u))*cos(3*pi*v);} function parametric_y(u,v,w) {return 0.03*pi*v*(10+5*cos(pi*u))*sin(3*pi*v);} function parametric_z(u,v,w) {return 0.03*pi*v*(6+5*sin(pi*u));}" type "script" } } FShape { Time-dependent color timespan diffusecolor "sin(sqrt(x*x+y*y+z*z) * pi + t)" patterncolor [ ] patternkey [-1 1] type "analytical" } } geometry FGeometry { resolution [ ] definition " function parametric_x(u,v,w) Final shape {return ( *sin(v*5*pi))*cos(v*pi)*(4+cos(u*pi));} function parametric_y(u,v,w) {return ( *sin(v*5*pi))*sin(v*pi)*(4+cos(u*pi));} function parametric_z(u,v,w) {return 0.2*sin(u*pi);}" type "script" } } ] Listing 4. Using user-defined operations and scripts The proposed FVRML extension is being used when teaching computer graphics at the School of Computer Engineering of Nanyang Technological University, Singapore. This is a part of computer graphics assignments Implicit Fantasies and Parametric Metamorphoses where the students have to design complex animated function-defined VRML scenes. These scenes are then used as meeting places of the Virtual Campus of NTU[16] a cyberworld built with blaxxun Contact platform, VRML, AIML, and multimedia files. The snapshot of the graphics window of the interactive collaborative modeling session at the Virtual Shape Modeling Laboratory [12,13], which is a part of the Virtual Campus, is shown in Figure 5. Figure 5. Parametric Metamorphoses in Collaborative Shape Modeling Laboratory 4. Implementation details During implementation, several important factors must be considered. First, the development platform must be chosen reasonably. Second, the visualization pipeline must be designed properly and efficiently. Finally, the implementation of scripts must be elegant and sufficient, since the functions require numerous evaluations. 4.1 Development platform When choosing the development platform, several considerations have been taken into account. First, FVRML extension is a general extension of the standard VRML, so its implementation must not stick to one specific browser. Though the implementation itself may not be portable across browsers or platforms, at least the source code of the implementation should be adaptable to other browsers with only minor modifications. Second, the implementation must act as a part of the existing

7 browser, rather than a stand-along application. Third, the implementation itself must be transparent so that its presence must not be evident to the user if they are not using it. Also, if not installed, no errors must happen when the FVRML code is found in the standard VRML code. Finally, the implementation must have good performance. Based on these considerations, we have investigated all possible ways of implementing FVRML: plug-in customization, VRML External Authoring Interface (EAI), and VRML script. We have chosen VRML script and C++ as the most optimal solution. VRML script is a part of the standard VRML, so it is browser-independent and can be integrated into the browsers. Scripts are totally transparent to the users. Even if they are missing, no errors will be generated. C++ is known as a very efficient programming language. Of course, it is not truly crossplatform, and there is no standard for implementing C++ scripts for different browsers. Nevertheless, since the architectures of the VRML browsers are similar, and we do not use any platform specific features, C++ codes can be easily ported to different browsers and platforms. 4.2 Script implementation details The compiler of the script is built with the skeleton code generated by Yet Another Compiler Compiler (YACC) from the Backus Naur Form (BNF) definition of the script. For each user-defined function, the intermediate code is generated and stored in the memory. In order to achieve better performance, the pre-defined mathematical functions are defined by C++ code instead of intermediate code. In order to simplify the implementation, for each expression in the script, no more than one thousand mathematical operations are allowed. Longer expressions are to be split into several notations using temporary variables. Since floating point number is the only possible data type, whenever accessing an array the index of the array will be rounded up to the nearest integer. For example, definition array[1.6] is equivalent to array[2]. 4.3 Visualization pipeline To implement time-dependent FVRML extension, a new visualization pipeline must have been designed. Furthermore, time-dependent objects should be rendered and changed continuously while users are able to interact and navigate through the virtual worlds. Thus, multithreading techniques have been adopted in order to avoid blocking interacting and rendering functionality of the VRML browsers. By taking it into account, our visualization pipeline for time-dependent FVRML objects consists of two threads and eight modules, which are Parser, Compiler, TimeGenerator, ShapeGenerator, TextureGenerator, ColorGenerator, TransformOperator, and Polygonizer. One thread is responsible for parsing and compiling the source code into an intermediate code executed by virtual machine, while the other thread is responsible for conversion of the time-dependent function-based model into polygons. For each specific frame, one set of polygons can be either generated on-the-fly or cached. 5. Conclusion and future work In this paper we propose a new function-based extension of VRML which allows for defining timedependent shapes. The shapes are defined by analytical functions, which define shape s geometry, 3D texture and color. All these functions can be functions of time. The functions can be grouped into scripts which follow the JavaScript syntax to be consistent with VRML. Custom time-dependent operations can be defined by analytical functions as well. With the proposed extension, programming of fancy animated shape metamorphoses becomes very easy in VRML. Sophisticated shaped can be defined without increasing the file size as it normally happens when polygon-based models of VRML97 are used. The developed FVRML extension was successfully used when teaching computer graphics and shape modeling at Nanyang Technological University. The FVRML plug-in and examples are available at the project s web page [17]. References [1] International Standardization Organization (ISO) ISO JTC1 SC24. VRML97, ISO/IEC , [2] Marc Alexa and Wolfgang Muller, The morphing space, Proc. WSCG 99, [3] Marc Alexa, Johannes Behr, and Wolfgang Muller, The morph node, Proc. 5th Symp. Virtual Reality ModelingLanguage (Web3D-VRML), 2000, pp [4] Humanoid Animation Working Group (H-ANIM), H- Anim 200x specification, [5] Toshiya Naka, Yoshiyuki Mochizuki, Toshiki Hijiri, Tim Cornish, and Shigeo Asahara, A compression/decompression method for streaming based humanoid animation, Proc. 4th Symp. Virtual Reality Modeling Language, 1999, pp [6] Yi-Lin Liu and Tsai-Yen Li, A multi-user virtual environment system with extensible animations, Proc. ACM Web3D, 2003, pp [7] Gaspard Breton, Christian Bouville, and Danielle Pele, FaceEngine a 3D facial animation engine for

8 real time applications, Proc. ACM Web3D 01, 2001, pp [8] Igor S. Pandzic, Facial animation framework for the web and mobile platforms, Proc. ACM Web3D 02, 2002, pp [9] Andrea Esuli, Antonio Cisternino, Giuliano Pacini, and Maria Simi, Multimodal presentation of dynamic object scenarios on the web, Proc. ACM Web3D 03, 2003, pp [10] Jonathan C. Roberts, Publishing Time Dependent Oceanographic Visualizations using VRML, Proc. 5th UK Virtual Reality Special Interest Group -- VRSIG '98, [11] R. Andrew Davies, Nigel W. John, John N. MacDonald, and Keith H. Hughes, Visualization of molecular quantum dynamics: a molecular visualization tool with integrated Web3D and haptics, Proc. ACM Web3D '05, 2005, pp [12] Qi Liu and Alexei Sourin, Function-based Representation of Complex Geometry Appearance, Proc. ACM Web3D '05, 2005, pp [13] Qi Liu, Alexei Sourin, Analytically-defined Collaborative Shape Modeling in VRML, Proc. Int. Conf. Cyberworlds, CW2004, Tokyo, November, 2004, pp [14] Lai Feng Min, Alexei Sourin, "Function-defined shape node for VRML", Eurographics 2002, Short Presentations, ISSN , pp , [15] A.A.Pasko, V.D.Adzhiev, A.I.Sourin, V.V.Savchenko, Function Representation in Geometric Modeling: Concepts, Implementations and Applications, Visual Computer, 11:8, 1995, [16] A.Sourin, Nanyang Technological University Virtual Campus, IEEE Computer Graphics & Applications, 24:6, 2004, 6-8. [17] Hybrid Function Based Web Visualization, Appendix. FVRML Prototypes PROTO FGeometry [ exposedfield SFString definition "" exposedfield MFFloat parameters [0] exposedfield MFInt32 resolution [ ] exposedfield SFVec3f bboxcenter exposedfield SFVec3f bboxsize exposedfield SFString type "" exposedfield SFVec2f timespan 0 1 ] PROTO FMaterial [ exposedfield SFString diffusecolor "" exposedfield SFString type "" exposedfield MFColor patterncolor [] exposedfield MFFloat patternkey [] exposedfield SFFloat ambientintensity 0.2 exposedfield SFColor emissivecolor exposedfield SFFloat shininess 0.2 exposedfield SFColor specularcolor exposedfield SFFloat transparency 0 exposedfield SFVec2f timespan 0 1 ] PROTO FTexture3D [ exposedfield SFString definition "" exposedfield SFString type "" exposedfield MFFloat parameters [0] exposedfield SFVec2f timespan 0 1 ] PROTO FAppearance [ exposedfield SFNode material NULL exposedfield SFNode texture NULL exposedfield SFNode texturetransform NULL exposedfield SFNode texture3d NULL eventin SFBool refresh ] PROTO FShape [ exposedfield SFNode geometry NULL exposedfield SFNode appearance NULL exposedfield SFString polygonizer "analytical" eventin SFBool refresh exposedfield SFTime starttime 0 exposedfield SFTime stoptime 0 exposedfield SFTime cycleinterval 1 exposedfield SFBool loop FALSE exposedfield SFBool enabled TRUE eventout SFTime cycletime eventin SFFloat set_fraction ] PROTO FTransform [ exposedfield SFString operation "union" exposedfield SFString type "setoperator" exposedfield SFString polygonizer "analytical" exposedfield MFFloat parameters [0] exposedfield SFVec3f center exposedfield SFRotation rotation exposedfield SFVec3f scale exposedfield SFRotation scaleorientation exposedfield SFVec3f translation exposedfield MFNode children [] eventin SFBool refresh exposedfield SFVec2f timespan 0 1 exposedfield SFTime starttime 0 exposedfield SFTime stoptime 0 exposedfield SFTime cycleinterval 1 exposedfield SFBool loop FALSE exposedfield SFBool enabled TRUE eventout SFTime cycletime eventin SFFloat set_fraction ]