internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			if(id=="beginCap") BeginCap=parser.ParseBoolValue();
			else if(id=="ccw") CCW=parser.ParseBoolValue();
			else if(id=="convex") Convex=parser.ParseBoolValue();
			else if(id=="creaseAngle") CreaseAngle=parser.ParseDoubleValue();
			else if(id=="crossSection")
			{
				if(wasCrossSection) CrossSection.AddRange(parser.ParseSFVec2fOrMFVec2fValue());
				else CrossSection=parser.ParseSFVec2fOrMFVec2fValue();
				wasCrossSection=true;
			}
			else if(id=="endCap") EndCap=parser.ParseBoolValue();
			else if(id=="orientation")
			{
				if(wasOrientation) Orientation.AddRange(parser.ParseSFRotationOrMFRotationValue());
				else Orientation=parser.ParseSFRotationOrMFRotationValue();
				wasOrientation=true;
			}
			else if(id=="scale")
			{
				if(wasScale) Scale.AddRange(parser.ParseSFVec2fOrMFVec2fValue());
				else Scale=parser.ParseSFVec2fOrMFVec2fValue();
				wasScale=true;
			}
			else if(id=="solid") Solid=parser.ParseBoolValue();
			else if(id=="spine")
			{
				if(wasSpine) Spine.AddRange(parser.ParseSFVec3fOrMFVec3fValue());
				else Spine=parser.ParseSFVec3fOrMFVec3fValue();
				wasSpine=true;
			}
			else return false;
			return true;
		}
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			if(id=="address") Address=parser.ParseStringValue();
			else if(id=="applicationID") ApplicationID=parser.ParseIntValue();
			else if(id=="data") Data.AddRange(parser.ParseSFInt32OrMFInt32Value());
			else if(id=="dataLength") DataLength=parser.ParseIntValue();
			else if(id=="enabled") Enabled=parser.ParseBoolValue();
			else if(id=="encodingScheme") EncodingScheme=parser.ParseIntValue();
			else if(id=="entityID") EntityID=parser.ParseIntValue();
			else if(id=="multicastRelayHost") MulticastRelayHost=parser.ParseStringValue();
			else if(id=="multicastRelayPort") MulticastRelayPort=parser.ParseIntValue();
			else if(id=="networkMode") NetworkMode=parser.ParseStringValue();
			else if(id=="port") Port=parser.ParseIntValue();
			else if(id=="radioID") RadioID=parser.ParseIntValue();
			else if(id=="readInterval") ReadInterval=parser.ParseDoubleValue();
			else if(id=="rtpHeaderExpected") RtpHeaderExpected=parser.ParseBoolValue();
			else if(id=="sampleRate") SampleRate=parser.ParseIntValue();
			else if(id=="samples") Samples=parser.ParseIntValue();
			else if(id=="siteID") SiteID=parser.ParseIntValue();
			else if(id=="tdlType") TdlType=parser.ParseIntValue();
			else if(id=="whichGeometry") WhichGeometry=parser.ParseIntValue();
			else if(id=="writeInterval") WriteInterval=parser.ParseDoubleValue();
			else if(id=="bboxCenter") BBoxCenter=parser.ParseSFVec3fValue();
			else if(id=="bboxSize") BBoxSize=parser.ParseSFVec3fValue();
			else return false;
			return true;
		}
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			if(id=="deletionAllowed") DeletionAllowed=parser.ParseBoolValue();
			else if(id=="enabled") Enabled=parser.ParseBoolValue();
			else return false;
			return true;
		}
 internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
 {
     if (id == "bottom")
     {
         Bottom = parser.ParseBoolValue();
     }
     else if (id == "height")
     {
         Height = parser.ParseDoubleValue();
     }
     else if (id == "radius")
     {
         Radius = parser.ParseDoubleValue();
     }
     else if (id == "side")
     {
         Side = parser.ParseBoolValue();
     }
     else if (id == "solid")
     {
         Solid = parser.ParseBoolValue();
     }
     else if (id == "top")
     {
         Top = parser.ParseBoolValue();
     }
     else
     {
         return(false);
     }
     return(true);
 }
Exemplo n.º 5
0
        internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
        {
            int line = parser.Line;

            if (id == "url")
            {
                URL.AddRange(parser.ParseSFStringOrMFStringValue());
            }
            else if (id == "repeatS")
            {
                RepeatS = parser.ParseBoolValue();
            }
            else if (id == "repeatT")
            {
                RepeatT = parser.ParseBoolValue();
            }
            else if (id == "textureProperties")
            {
                X3DNode node = parser.ParseSFNodeValue();
                if (node != null)
                {
                    TextureProperties = node as IX3DTexturePropertiesNode;
                    if (TextureProperties == null)
                    {
                        parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
                    }
                }
            }
            else
            {
                return(false);
            }
            return(true);
        }
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			int line=parser.Line;

			if(id=="crossSectionCurve")
			{
				X3DNode node=parser.ParseSFNodeValue();
				if(node!=null)
				{
					CrossSectionCurve=node as X3DNurbsControlCurveNode;
					if(CrossSectionCurve==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
				}
			}
			else if(id=="trajectoryCurve")
			{
				X3DNode node=parser.ParseSFNodeValue();
				if(node!=null)
				{
					TrajectoryCurve=node as IX3DNurbsCurveNode;
					if(TrajectoryCurve==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
				}
			}
			else if(id=="ccw") CCW=parser.ParseBoolValue();
			else if(id=="solid") Solid=parser.ParseBoolValue();
			else return false;
			return true;
		}
Exemplo n.º 7
0
 internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
 {
     if (id == "family")
     {
         if (wasFamily)
         {
             Family.AddRange(parser.ParseSFStringOrMFStringValue());
         }
         else
         {
             Family = parser.ParseSFStringOrMFStringValue();
         }
         wasFamily = true;
     }
     else if (id == "horizontal")
     {
         Horizontal = parser.ParseBoolValue();
     }
     else if (id == "justify")
     {
         if (wasJustify)
         {
             Justify.AddRange(parser.ParseSFStringOrMFStringValue());
         }
         else
         {
             Justify = parser.ParseSFStringOrMFStringValue();
         }
         wasJustify = true;
     }
     else if (id == "language")
     {
         Language = parser.ParseStringValue();
     }
     else if (id == "leftToRight")
     {
         LeftToRight = parser.ParseBoolValue();
     }
     else if (id == "pointSize")
     {
         PointSize = parser.ParseDoubleValue();
     }
     else if (id == "spacing")
     {
         Spacing = parser.ParseDoubleValue();
     }
     else if (id == "style")
     {
         Style = parser.ParseStringValue();
     }
     else if (id == "topToBottom")
     {
         TopToBottom = parser.ParseBoolValue();
     }
     else
     {
         return(false);
     }
     return(true);
 }
 internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
 {
     if (id == "ambientIntensity")
     {
         AmbientIntensity = parser.ParseDoubleValue();
     }
     else if (id == "color")
     {
         Color = parser.ParseSFColorValue();
     }
     else if (id == "direction")
     {
         Direction = parser.ParseSFVec3fValue();
     }
     else if (id == "global")
     {
         Global = parser.ParseBoolValue();
     }
     else if (id == "intensity")
     {
         Intensity = parser.ParseDoubleValue();
     }
     else if (id == "on")
     {
         On = parser.ParseBoolValue();
     }
     else
     {
         return(false);
     }
     return(true);
 }
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			int line=parser.Line;

			if(id=="description") Description=parser.ParseStringValue();
			else if(id=="loop") Loop=parser.ParseBoolValue();
			else if(id=="pauseTime") PauseTime=parser.ParseDoubleValue();
			else if(id=="resumeTime") ResumeTime=parser.ParseDoubleValue();
			else if(id=="speed"||id=="pitch") Pitch=parser.ParseDoubleValue();
			else if(id=="startTime") StartTime=parser.ParseDoubleValue();
			else if(id=="stopTime") StopTime=parser.ParseDoubleValue();
			else if(id=="url") URL.AddRange(parser.ParseSFStringOrMFStringValue());
			else if(id=="repeatS") RepeatS=parser.ParseBoolValue();
			else if(id=="repeatT") RepeatT=parser.ParseBoolValue();
			else if(id=="textureProperties")
			{
				X3DNode node=parser.ParseSFNodeValue();
				if(node!=null)
				{
					TextureProperties=node as IX3DTexturePropertiesNode;
					if(TextureProperties==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
				}
			}
			else return false;
			return true;
		}
Exemplo n.º 10
0
 internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
 {
     if (id == "collidables")
     {
         Collidables.AddRange(parser.ParseSFNodeOrMFNodeValue());
     }
     else if (id == "enabled")
     {
         Enabled = parser.ParseBoolValue();
     }
     else if (id == "useGeometry")
     {
         UseGeometry = parser.ParseBoolValue();
     }
     else if (id == "bboxCenter")
     {
         BBoxCenter = parser.ParseSFVec3fValue();
     }
     else if (id == "bboxSize")
     {
         BBoxSize = parser.ParseSFVec3fValue();
     }
     else
     {
         return(false);
     }
     return(true);
 }
Exemplo n.º 11
0
 internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
 {
     if (id == "closed")
     {
         Closed = parser.ParseBoolValue();
     }
     else if (id == "key")
     {
         Key.AddRange(parser.ParseSFFloatOrMFFloatValue());
     }
     else if (id == "keyValue")
     {
         KeyValue.AddRange(parser.ParseSFVec2fOrMFVec2fValue());
     }
     else if (id == "keyVelocity")
     {
         KeyVelocity.AddRange(parser.ParseSFVec2fOrMFVec2fValue());
     }
     else if (id == "normalizeVelocity")
     {
         NormalizeVelocity = parser.ParseBoolValue();
     }
     else
     {
         return(false);
     }
     return(true);
 }
Exemplo n.º 12
0
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			if(id=="url") URL.AddRange(parser.ParseSFStringOrMFStringValue());
			else if(id=="directOutput") DirectOutput=parser.ParseBoolValue();
			else if(id=="mustEvaluate") MustEvaluate=parser.ParseBoolValue();
			else return false;
			return true;
		}
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			if(id=="autoOffset") AutoOffset=parser.ParseBoolValue();
			else if(id=="description") Description=parser.ParseStringValue();
			else if(id=="enabled") Enabled=parser.ParseBoolValue();
			else if(id=="offset") Offset=parser.ParseSFRotationValue();
			else return false;
			return true;
		}
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			if(id=="filled") Filled=parser.ParseBoolValue();
			else if(id=="hatchColor") HatchColor=parser.ParseSFColorValue();
			else if(id=="hatched") Hatched=parser.ParseBoolValue();
			else if(id=="hatchStyle") HatchStyle=parser.ParseIntValue();
			else return false;
			return true;
		}
Exemplo n.º 15
0
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			if(id=="bottom") Bottom=parser.ParseBoolValue();
			else if(id=="bottomRadius") BottomRadius=parser.ParseDoubleValue();
			else if(id=="height") Height=parser.ParseDoubleValue();
			else if(id=="side") Side=parser.ParseBoolValue();
			else if(id=="solid") Solid=parser.ParseBoolValue();
			else return false;
			return true;
		}
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			if(id=="collidables") Collidables.AddRange(parser.ParseSFNodeOrMFNodeValue());
			else if(id=="enabled") Enabled=parser.ParseBoolValue();
			else if(id=="useGeometry") UseGeometry=parser.ParseBoolValue();
			else if(id=="bboxCenter") BBoxCenter=parser.ParseSFVec3fValue();
			else if(id=="bboxSize") BBoxSize=parser.ParseSFVec3fValue();
			else return false;
			return true;
		}
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			if(id=="ambientIntensity") AmbientIntensity=parser.ParseDoubleValue();
			else if(id=="color") Color=parser.ParseSFColorValue();
			else if(id=="direction") Direction=parser.ParseSFVec3fValue();
			else if(id=="global") Global=parser.ParseBoolValue();
			else if(id=="intensity") Intensity=parser.ParseDoubleValue();
			else if(id=="on") On=parser.ParseBoolValue();
			else return false;
			return true;
		}
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			if(id=="cycleInterval") CycleInterval=parser.ParseDoubleValue();
			else if(id=="enabled") Enabled=parser.ParseBoolValue();
			else if(id=="loop") Loop=parser.ParseBoolValue();
			else if(id=="pauseTime") PauseTime=parser.ParseDoubleValue();
			else if(id=="resumeTime") ResumeTime=parser.ParseDoubleValue();
			else if(id=="startTime") StartTime=parser.ParseDoubleValue();
			else if(id=="stopTime") StopTime=parser.ParseDoubleValue();
			else return false;
			return true;
		}
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			if(id=="centerOfRotation") CenterOfRotation=parser.ParseSFVec3fValue();
			else if(id=="description") Description=parser.ParseStringValue();
			else if(id=="fieldOfView") FieldOfView=parser.ParseDoubleValue();
			else if(id=="jump") Jump=parser.ParseBoolValue();
			else if(id=="orientation") Orientation=parser.ParseSFRotationValue();
			else if(id=="position") Position=parser.ParseSFVec3fValue();
			else if(id=="retainUserOffsets") RetainUserOffsets=parser.ParseBoolValue();
			else return false;
			return true;
		}
Exemplo n.º 20
0
 internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
 {
     if (id == "ambientIntensity")
     {
         AmbientIntensity = parser.ParseDoubleValue();
     }
     else if (id == "attenuation")
     {
         Attenuation = parser.ParseSFVec3fValue();
     }
     else if (id == "beamWidth")
     {
         BeamWidth = parser.ParseDoubleValue();
     }
     else if (id == "color")
     {
         Color = parser.ParseSFColorValue();
     }
     else if (id == "cutOffAngle")
     {
         CutOffAngle = parser.ParseDoubleValue();
     }
     else if (id == "direction")
     {
         Direction = parser.ParseSFVec3fValue();
     }
     else if (id == "global")
     {
         Global = parser.ParseBoolValue();
     }
     else if (id == "intensity")
     {
         Intensity = parser.ParseDoubleValue();
     }
     else if (id == "location")
     {
         Location = parser.ParseSFVec3fValue();
     }
     else if (id == "on")
     {
         On = parser.ParseBoolValue();
     }
     else if (id == "radius")
     {
         Radius = parser.ParseDoubleValue();
     }
     else
     {
         return(false);
     }
     return(true);
 }
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			int line=parser.Line;

			if(id=="autoDisable") AutoDisable=parser.ParseBoolValue();
			else if(id=="bodies")
			{
				List<X3DNode> nodes=parser.ParseSFNodeOrMFNodeValue();
				foreach(X3DNode node in nodes)
				{
					IX3DRigidBodyNode rb=node as IX3DRigidBodyNode;
					if(rb==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
					else Bodies.Add(rb);
				}
			}
			else if(id=="constantForceMix") ConstantForceMix=parser.ParseDoubleValue();
			else if(id=="contactSurfaceThickness") ContactSurfaceThickness=parser.ParseDoubleValue();
			else if(id=="disableAngularSpeed") DisableAngularSpeed=parser.ParseDoubleValue();
			else if(id=="disableLinearSpeed") DisableLinearSpeed=parser.ParseDoubleValue();
			else if(id=="disableTime") DisableTime=parser.ParseDoubleValue();
			else if(id=="enabled") Enabled=parser.ParseBoolValue();
			else if(id=="errorCorrection") ErrorCorrection=parser.ParseDoubleValue();
			else if(id=="gravity") Gravity=parser.ParseSFVec3fValue();
			else if(id=="iterations") Iterations=parser.ParseIntValue();
			else if(id=="joints")
			{
				List<X3DNode> nodes=parser.ParseSFNodeOrMFNodeValue();
				foreach(X3DNode node in nodes)
				{
					X3DRigidJointNode rj=node as X3DRigidJointNode;
					if(rj==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
					else Joints.Add(rj);
				}
			}
			else if(id=="maxCorrectionSpeed") MaxCorrectionSpeed=parser.ParseDoubleValue();
			else if(id=="preferAccuracy") PreferAccuracy=parser.ParseBoolValue();
			else if(id=="collider")
			{
				X3DNode node=parser.ParseSFNodeValue();
				if(node!=null)
				{
					Collider=node as IX3DCollisionCollectionNode;
					if(Collider==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
				}
			}
			else return false;
			return true;
		}
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			if(id=="enabled") Enabled=parser.ParseBoolValue();
			else if(id=="name") Name=parser.ParseStringValue();
			else return false;
			return true;
		}
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			int line=parser.Line;

			if(id=="enabled") Enabled=parser.ParseBoolValue();
			else if(id=="objectType")
			{
				if(wasObjectType) ObjectType.AddRange(parser.ParseSFStringOrMFStringValue());
				else ObjectType=parser.ParseSFStringOrMFStringValue();
				wasObjectType=true;
			}
			else if(id=="pickingGeometry")
			{
				X3DNode node=parser.ParseSFNodeValue();
				if(node!=null)
				{
					PickingGeometry=node as IX3DLinePickSensorPickingGeometry;
					if(PickingGeometry==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
				}
			}
			else if(id=="pickTarget")
			{
				List<X3DNode> nodes=parser.ParseSFNodeOrMFNodeValue();
				foreach(X3DNode node in nodes)
				{
					IX3DPickSensorNodePickTarget pt=node as IX3DPickSensorNodePickTarget;
					if(pt==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
					else PickTarget.Add(pt);
				}
			}
			else if(id=="intersectionType") IntersectionType=parser.ParseStringValue();
			else if(id=="sortOrder") SortOrder=parser.ParseStringValue();
			else return false;
			return true;
		}
 internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
 {
     if (id == "avatarSize")
     {
         if (wasAvatarSize)
         {
             AvatarSize.AddRange(parser.ParseSFFloatOrMFFloatValue());
         }
         else
         {
             AvatarSize = parser.ParseSFFloatOrMFFloatValue();
         }
         wasAvatarSize = true;
     }
     else if (id == "headlight")
     {
         Headlight = parser.ParseBoolValue();
     }
     else if (id == "speed")
     {
         Speed = parser.ParseDoubleValue();
     }
     else if (id == "transitionTime")
     {
         TransitionTime = parser.ParseDoubleValue();
     }
     else if (id == "transitionType")
     {
         if (wasTransitionType)
         {
             TransitionType.AddRange(parser.ParseSFStringOrMFStringValue());
         }
         else
         {
             TransitionType = parser.ParseSFStringOrMFStringValue();
         }
         wasTransitionType = true;
     }
     else if (id == "type")
     {
         if (wasType)
         {
             Type.AddRange(parser.ParseSFStringOrMFStringValue());
         }
         else
         {
             Type = parser.ParseSFStringOrMFStringValue();
         }
         wasType = true;
     }
     else if (id == "visibilityLimit")
     {
         VisibilityLimit = parser.ParseDoubleValue();
     }
     else
     {
         return(false);
     }
     return(true);
 }
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			if(id=="enabled") Enabled=parser.ParseBoolValue();
			else if(id=="force") Force=parser.ParseSFVec3fValue();
			else return false;
			return true;
		}
 internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
 {
     if (id == "description")
     {
         Description = parser.ParseStringValue();
     }
     else if (id == "loop")
     {
         Loop = parser.ParseBoolValue();
     }
     else if (id == "pitch")
     {
         Pitch = parser.ParseDoubleValue();
     }
     else if (id == "startTime")
     {
         StartTime = parser.ParseDoubleValue();
     }
     else if (id == "stopTime")
     {
         StopTime = parser.ParseDoubleValue();
     }
     else if (id == "url")
     {
         URL.AddRange(parser.ParseSFStringOrMFStringValue());
     }
     else
     {
         return(false);
     }
     return(true);
 }
Exemplo n.º 27
0
        internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
        {
            int line = parser.Line;

            if (id == "enabled")
            {
                Enabled = parser.ParseBoolValue();
            }
            else if (id == "geometry")
            {
                X3DNode node = parser.ParseSFNodeValue();
                if (node != null)
                {
                    Geometry = node as X3DGeometryNode;
                    if (Geometry == null)
                    {
                        parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
                    }
                }
            }
            else
            {
                return(false);
            }
            return(true);
        }
 internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
 {
     if (id == "closureType")
     {
         ClosureType = parser.ParseStringValue();
     }
     else if (id == "endAngle")
     {
         EndAngle = parser.ParseDoubleValue();
     }
     else if (id == "radius")
     {
         Radius = parser.ParseDoubleValue();
     }
     else if (id == "solid")
     {
         Solid = parser.ParseBoolValue();
     }
     else if (id == "startAngle")
     {
         StartAngle = parser.ParseDoubleValue();
     }
     else
     {
         return(false);
     }
     return(true);
 }
Exemplo n.º 29
0
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			int line=parser.Line;

			if(id=="children")
			{
				List<X3DNode> nodes=parser.ParseSFNodeOrMFNodeValue();
				foreach(X3DNode node in nodes)
				{
					X3DChildNode child=node as X3DChildNode;
					if(child==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
					else Children.Add(child);
				}
			}
			else if(id=="isPickable") IsPickable=parser.ParseBoolValue();
			else if(id=="viewport")
			{
				X3DNode node=parser.ParseSFNodeValue();
				if(node!=null)
				{
					Viewport=node as X3DViewportNode;
					if(Viewport==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
				}
			}
			else return false;
			return true;
		}
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			int line=parser.Line;

			if(id=="enabled") Enabled=parser.ParseBoolValue();
			else if(id=="geoCenter") GeoCenter=parser.ParseSFVec3fValue();
			else if(id=="size") Size=parser.ParseSFVec3fValue();
			else if(id=="geoOrigin")
			{
				X3DNode node=parser.ParseSFNodeValue();
				if(node!=null)
				{
					GeoOrigin=node as IX3DGeoOriginNode;
					if(GeoOrigin==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
				}
			}
			else if(id=="geoSystem")
			{
				if(wasGeoSystem) GeoSystem.AddRange(parser.ParseSFStringOrMFStringValue());
				else GeoSystem=parser.ParseSFStringOrMFStringValue();
				wasGeoSystem=true;
			}
			else return false;
			return true;
		}
Exemplo n.º 31
0
 internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
 {
     if (id == "controlPoint")
     {
         ControlPoint.AddRange(parser.ParseSFVec2fOrMFVec2fValue());
     }
     else if (id == "tessellation")
     {
         Tessellation = parser.ParseIntValue();
     }
     else if (id == "weight")
     {
         Weight.AddRange(parser.ParseSFFloatOrMFFloatValue());
     }
     else if (id == "closed")
     {
         Closed = parser.ParseBoolValue();
     }
     else if (id == "knot")
     {
         Knot.AddRange(parser.ParseSFFloatOrMFFloatValue());
     }
     else if (id == "order")
     {
         Order = parser.ParseIntValue();
     }
     else
     {
         return(false);
     }
     return(true);
 }
Exemplo n.º 32
0
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			int line=parser.Line;

			if(id=="direction") Direction=parser.ParseSFVec3fValue();
			else if(id=="intensity") Intensity=parser.ParseDoubleValue();
			else if(id=="location") Location=parser.ParseSFVec3fValue();
			else if(id=="maxBack") MaxBack=parser.ParseDoubleValue();
			else if(id=="maxFront") MaxFront=parser.ParseDoubleValue();
			else if(id=="minBack") MinBack=parser.ParseDoubleValue();
			else if(id=="minFront") MinFront=parser.ParseDoubleValue();
			else if(id=="priority") Priority=parser.ParseDoubleValue();
			else if(id=="source")
			{
				X3DNode node=parser.ParseSFNodeValue();
				if(node!=null)
				{
					Source=node as X3DSoundSourceNode;
					if(Source==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
				}
			}
			else if(id=="spatialize") Spatialize=parser.ParseBoolValue();
			else return false;
			return true;
		}
Exemplo n.º 33
0
        internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
        {
            int line = parser.Line;

            if (id == "collidables" || id == "collider")
            {
                X3DNode node = parser.ParseSFNodeValue();
                if (node != null)
                {
                    Collider = node as IX3DCollisionCollectionNode;
                    if (Collider == null)
                    {
                        parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
                    }
                }
            }
            else if (id == "enabled")
            {
                Enabled = parser.ParseBoolValue();
            }
            else
            {
                return(false);
            }
            return(true);
        }
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			if(id=="ambientIntensity") AmbientIntensity=parser.ParseDoubleValue();
			else if(id=="attenuation") Attenuation=parser.ParseSFVec3fValue();
			else if(id=="beamWidth") BeamWidth=parser.ParseDoubleValue();
			else if(id=="color") Color=parser.ParseSFColorValue();
			else if(id=="cutOffAngle") CutOffAngle=parser.ParseDoubleValue();
			else if(id=="direction") Direction=parser.ParseSFVec3fValue();
			else if(id=="global") Global=parser.ParseBoolValue();
			else if(id=="intensity") Intensity=parser.ParseDoubleValue();
			else if(id=="location") Location=parser.ParseSFVec3fValue();
			else if(id=="on") On=parser.ParseBoolValue();
			else if(id=="radius") Radius=parser.ParseDoubleValue();
			else return false;
			return true;
		}
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			if(id=="vertices")Vertices.AddRange(parser.ParseSFVec2fOrMFVec2fValue());
			else if(id=="solid") Solid=parser.ParseBoolValue();
			else return false;
			return true;
		}
 internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
 {
     if (id == "direction")
     {
         Direction = parser.ParseSFVec3fValue();
     }
     else if (id == "enabled")
     {
         Enabled = parser.ParseBoolValue();
     }
     else if (id == "gustiness")
     {
         Gustiness = parser.ParseDoubleValue();
     }
     else if (id == "speed")
     {
         Speed = parser.ParseDoubleValue();
     }
     else if (id == "turbulence")
     {
         Turbulence = parser.ParseDoubleValue();
     }
     else
     {
         return(false);
     }
     return(true);
 }
 internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
 {
     if (id == "geoCoords")
     {
         GeoCoords = parser.ParseSFVec3fStringValue();
     }
     else if (id == "geoSystem")
     {
         if (wasGeoSystem)
         {
             GeoSystem.AddRange(parser.ParseSFStringOrMFStringValue());
         }
         else
         {
             GeoSystem = parser.ParseSFStringOrMFStringValue();
         }
         wasGeoSystem = true;
     }
     else if (id == "rotateYUp")
     {
         RotateYUp = parser.ParseBoolValue();
     }
     else
     {
         return(false);
     }
     return(true);
 }
 internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
 {
     if (id == "deletionAllowed")
     {
         DeletionAllowed = parser.ParseBoolValue();
     }
     else if (id == "enabled")
     {
         Enabled = parser.ParseBoolValue();
     }
     else
     {
         return(false);
     }
     return(true);
 }
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			int line=parser.Line;

			if(id=="children")
			{
				List<X3DNode> nodes=parser.ParseSFNodeOrMFNodeValue();
				foreach(X3DNode node in nodes)
				{
					X3DChildNode child=node as X3DChildNode;
					if(child==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
					else Children.Add(child);
				}
			}
			else if(id=="objectType")
			{
				if(wasObjectType) ObjectType.AddRange(parser.ParseSFStringOrMFStringValue());
				else ObjectType=parser.ParseSFStringOrMFStringValue();
				wasObjectType=true;
			}
			else if(id=="pickable") Pickable=parser.ParseBoolValue();
			else if(id=="bboxCenter") BBoxCenter=parser.ParseSFVec3fValue();
			else if(id=="bboxSize") BBoxSize=parser.ParseSFVec3fValue();
			else return false;
			return true;
		}
        internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
        {
            int line = parser.Line;

            if (id == "enabled")
            {
                Enabled = parser.ParseBoolValue();
            }
            else if (id == "timeOut")
            {
                TimeOut = parser.ParseDoubleValue();
            }
            else if (id == "watchList")
            {
                List <X3DNode> nodes = parser.ParseSFNodeOrMFNodeValue();
                foreach (X3DNode node in nodes)
                {
                    X3DUrlObject url = node as X3DUrlObject;
                    if (url == null)
                    {
                        parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
                    }
                    else
                    {
                        WatchList.Add(url);
                    }
                }
            }
            else
            {
                return(false);
            }
            return(true);
        }
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			if(id=="enabled") Enabled=parser.ParseBoolValue();
			else if(id=="name") Name=parser.ParseStringValue();
			else return false;
			return true;
		}
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			int line=parser.Line;

			if(id=="coord")
			{
				X3DNode node=parser.ParseSFNodeValue();
				if(node!=null)
				{
					Coord=node as X3DCoordinateNode;
					if(Coord==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
				}
			}
			else if(id=="direction") Direction=parser.ParseSFVec3fValue();
			else if(id=="speed") Speed=parser.ParseDoubleValue();
			else if(id=="variation") Variation=parser.ParseDoubleValue();
			else if(id=="coordIndex")
			{
				if(wasCoordIndex) CoordIndex.AddRange(parser.ParseSFInt32OrMFInt32Value());
				else CoordIndex=parser.ParseSFInt32OrMFInt32Value();
				wasCoordIndex=true;
			}
			else if(id=="internal") Internal=parser.ParseBoolValue();
			else if(id=="mass") Mass=parser.ParseDoubleValue();
			else if(id=="surfaceArea") SurfaceArea=parser.ParseDoubleValue();
			else return false;
			return true;
		}
        internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
        {
            int line = parser.Line;

            if (id == "center")
            {
                Center = parser.ParseSFVec3fValue();
            }
            else if (id == "enabled")
            {
                Enabled = parser.ParseBoolValue();
            }
            else if (id == "size")
            {
                Size = parser.ParseSFVec3fValue();
            }
            else if (id == "targetObject")
            {
                X3DNode node = parser.ParseSFNodeValue();
                if (node != null)
                {
                    TargetObject = node as IX3DTranformSensorTargetObject;
                    if (TargetObject == null)
                    {
                        parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
                    }
                }
            }
            else
            {
                return(false);
            }
            return(true);
        }
Exemplo n.º 44
0
 internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
 {
     if (id == "ambientIntensity")
     {
         AmbientIntensity = parser.ParseDoubleValue();
     }
     else if (id == "backAmbientIntensity")
     {
         BackAmbientIntensity = parser.ParseDoubleValue();
     }
     else if (id == "backDiffuseColor")
     {
         BackDiffuseColor = parser.ParseSFColorValue();
     }
     else if (id == "backEmissiveColor")
     {
         BackEmissiveColor = parser.ParseSFColorValue();
     }
     else if (id == "backShininess")
     {
         BackShininess = parser.ParseDoubleValue();
     }
     else if (id == "backSpecularColor")
     {
         BackSpecularColor = parser.ParseSFColorValue();
     }
     else if (id == "backTransparency")
     {
         BackTransparency = parser.ParseDoubleValue();
     }
     else if (id == "diffuseColor")
     {
         DiffuseColor = parser.ParseSFColorValue();
     }
     else if (id == "emissiveColor")
     {
         EmissiveColor = parser.ParseSFColorValue();
     }
     else if (id == "shininess")
     {
         Shininess = parser.ParseDoubleValue();
     }
     else if (id == "separateBackColor")
     {
         SeparateBackColor = parser.ParseBoolValue();
     }
     else if (id == "specularColor")
     {
         SpecularColor = parser.ParseSFColorValue();
     }
     else if (id == "transparency")
     {
         Transparency = parser.ParseDoubleValue();
     }
     else
     {
         return(false);
     }
     return(true);
 }
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			int line=parser.Line;

			if(id=="children")
			{
				List<X3DNode> nodes=parser.ParseSFNodeOrMFNodeValue();
				foreach(X3DNode node in nodes)
				{
					X3DChildNode child=node as X3DChildNode;
					if(child==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
					else Children.Add(child);
				}
			}
			else if(id=="collide"||id=="enabled") Enabled=parser.ParseBoolValue();
			else if(id=="bboxCenter") BBoxCenter=parser.ParseSFVec3fValue();
			else if(id=="bboxSize") BBoxSize=parser.ParseSFVec3fValue();
			else if(id=="proxy")
			{
				X3DNode node=parser.ParseSFNodeValue();
				if(node!=null)
				{
					Proxy=node as X3DChildNode;
					if(Proxy==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
				}
			}
			else return false;
			return true;
		}
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			int line=parser.Line;

			if(id=="controlPoint")
			{
				X3DNode node=parser.ParseSFNodeValue();
				if(node!=null)
				{
					ControlPoint=node as X3DCoordinateNode;
					if(ControlPoint==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
				}
			}
			else if(id=="texCoord")
			{
				X3DNode node=parser.ParseSFNodeValue();
				if(node!=null)
				{
					TexCoord=node as IX3DNurbsSurfaceGeometryNodeTexCoord;
					if(TexCoord==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
				}
			}
			else if(id=="trimmingContour")
			{
				List<X3DNode> nodes=parser.ParseSFNodeOrMFNodeValue();
				foreach(X3DNode node in nodes)
				{
					IX3DContour2DNode contour=node as IX3DContour2DNode;
					if(contour==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
					else TrimmingContour.Add(contour);
				}
			}
			else if(id=="uTessellation") UTessellation=parser.ParseIntValue();
			else if(id=="vTessellation") VTessellation=parser.ParseIntValue();
			else if(id=="weight") Weight.AddRange(parser.ParseSFFloatOrMFFloatValue());
			else if(id=="solid") Solid=parser.ParseBoolValue();
			else if(id=="uClosed") UClosed=parser.ParseBoolValue();
			else if(id=="uDimension") UDimension=parser.ParseIntValue();
			else if(id=="uKnot") UKnot.AddRange(parser.ParseSFFloatOrMFFloatValue());
			else if(id=="uOrder") UOrder=parser.ParseIntValue();
			else if(id=="vClosed") VClosed=parser.ParseBoolValue();
			else if(id=="vDimension") VDimension=parser.ParseIntValue();
			else if(id=="vKnot") VKnot.AddRange(parser.ParseSFFloatOrMFFloatValue());
			else if(id=="vOrder") VOrder=parser.ParseIntValue();
			else return false;
			return true;
		}
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			int line=parser.Line;

			if(id=="angularDampingFactor") AngularDampingFactor=parser.ParseDoubleValue();
			else if(id=="angularVelocity") AngularVelocity=parser.ParseSFVec3fValue();
			else if(id=="autoDamp") AutoDamp=parser.ParseBoolValue();
			else if(id=="autoDisable") AutoDisable=parser.ParseBoolValue();
			else if(id=="centerOfMass") CenterOfMass=parser.ParseSFVec3fValue();
			else if(id=="disableAngularSpeed") DisableAngularSpeed=parser.ParseDoubleValue();
			else if(id=="disableLinearSpeed") DisableLinearSpeed=parser.ParseDoubleValue();
			else if(id=="disableTime") DisableTime=parser.ParseDoubleValue();
			else if(id=="enabled") Enabled=parser.ParseBoolValue();
			else if(id=="finiteRotationAxis") FiniteRotationAxis=parser.ParseSFVec3fValue();
			else if(id=="fixed") Fixed=parser.ParseBoolValue();
			else if(id=="forces") Forces.AddRange(parser.ParseSFVec3fOrMFVec3fValue());
			else if(id=="geometry")
			{
				List<X3DNode> nodes=parser.ParseSFNodeOrMFNodeValue();
				foreach(X3DNode node in nodes)
				{
					X3DNBodyCollidableNode nbcn=node as X3DNBodyCollidableNode;
					if(nbcn==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
					else Geometry.Add(nbcn);
				}
			}
			else if(id=="inertia") Inertia=parser.ParseSFMatrix3fValue();
			else if(id=="linearDampingFactor") LinearDampingFactor=parser.ParseDoubleValue();
			else if(id=="linearVelocity") LinearVelocity=parser.ParseSFVec3fValue();
			else if(id=="mass") Mass=parser.ParseDoubleValue();
			else if(id=="massDensityModel")
			{
				X3DNode node=parser.ParseSFNodeValue();
				if(node!=null)
				{
					MassDensityModel=node as X3DGeometryNode;
					if(MassDensityModel==null) parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
				}
			}
			else if(id=="orientation") Orientation=parser.ParseSFRotationValue();
			else if(id=="position") Position=parser.ParseSFVec3fValue();
			else if(id=="torques") Torques.AddRange(parser.ParseSFVec3fOrMFVec3fValue());
			else if(id=="useFiniteRotation") UseFiniteRotation=parser.ParseBoolValue();
			else if(id=="useGlobalGravity") UseGlobalGravity=parser.ParseBoolValue();
			else return false;
			return true;
		}
Exemplo n.º 48
0
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			if(id=="innerRadius") InnerRadius=parser.ParseDoubleValue();
			else if(id=="outerRadius") OuterRadius=parser.ParseDoubleValue();
			else if(id=="solid") Solid=parser.ParseBoolValue();
			else return false;
			return true;
		}
Exemplo n.º 49
0
        internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
        {
            int line = parser.Line;

            if (id == "center")
            {
                Center = parser.ParseSFVec3fValue();
            }
            else if (id == "children")
            {
                List <X3DNode> nodes = parser.ParseSFNodeOrMFNodeValue();
                foreach (X3DNode node in nodes)
                {
                    IX3DViewpointgroupChildren child = node as IX3DViewpointgroupChildren;
                    if (child == null)
                    {
                        parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
                    }
                    else
                    {
                        Children.Add(child);
                    }
                }
            }
            else if (id == "description")
            {
                Description = parser.ParseStringValue();
            }
            else if (id == "displayed")
            {
                Displayed = parser.ParseBoolValue();
            }
            else if (id == "retainUserOffsets")
            {
                RetainUserOffsets = parser.ParseBoolValue();
            }
            else if (id == "size")
            {
                Size = parser.ParseSFVec3fValue();
            }
            else
            {
                return(false);
            }
            return(true);
        }
Exemplo n.º 50
0
        internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
        {
            int line = parser.Line;

            if (id == "direction")
            {
                Direction = parser.ParseSFVec3fValue();
            }
            else if (id == "intensity")
            {
                Intensity = parser.ParseDoubleValue();
            }
            else if (id == "location")
            {
                Location = parser.ParseSFVec3fValue();
            }
            else if (id == "maxBack")
            {
                MaxBack = parser.ParseDoubleValue();
            }
            else if (id == "maxFront")
            {
                MaxFront = parser.ParseDoubleValue();
            }
            else if (id == "minBack")
            {
                MinBack = parser.ParseDoubleValue();
            }
            else if (id == "minFront")
            {
                MinFront = parser.ParseDoubleValue();
            }
            else if (id == "priority")
            {
                Priority = parser.ParseDoubleValue();
            }
            else if (id == "source")
            {
                X3DNode node = parser.ParseSFNodeValue();
                if (node != null)
                {
                    Source = node as X3DSoundSourceNode;
                    if (Source == null)
                    {
                        parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
                    }
                }
            }
            else if (id == "spatialize")
            {
                Spatialize = parser.ParseBoolValue();
            }
            else
            {
                return(false);
            }
            return(true);
        }
Exemplo n.º 51
0
        internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
        {
            int line = parser.Line;

            if (id == "coord")
            {
                X3DNode node = parser.ParseSFNodeValue();
                if (node != null)
                {
                    Coord = node as X3DCoordinateNode;
                    if (Coord == null)
                    {
                        parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
                    }
                }
            }
            else if (id == "direction")
            {
                Direction = parser.ParseSFVec3fValue();
            }
            else if (id == "speed")
            {
                Speed = parser.ParseDoubleValue();
            }
            else if (id == "variation")
            {
                Variation = parser.ParseDoubleValue();
            }
            else if (id == "coordIndex")
            {
                if (wasCoordIndex)
                {
                    CoordIndex.AddRange(parser.ParseSFInt32OrMFInt32Value());
                }
                else
                {
                    CoordIndex = parser.ParseSFInt32OrMFInt32Value();
                }
                wasCoordIndex = true;
            }
            else if (id == "internal")
            {
                Internal = parser.ParseBoolValue();
            }
            else if (id == "mass")
            {
                Mass = parser.ParseDoubleValue();
            }
            else if (id == "surfaceArea")
            {
                SurfaceArea = parser.ParseDoubleValue();
            }
            else
            {
                return(false);
            }
            return(true);
        }
Exemplo n.º 52
0
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			if(id=="color") Color=parser.ParseSFColorValue();
			else if(id=="enabled") Enabled=parser.ParseBoolValue();
			else if(id=="fogType") FogType=parser.ParseStringValue();
			else if(id=="visibilityRange") VisibilityRange=parser.ParseDoubleValue();
			else return false;
			return true;
		}
Exemplo n.º 53
0
		internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
		{
			if(id=="load") Load=parser.ParseBoolValue();
			else if(id=="url") URL.AddRange(parser.ParseSFStringOrMFStringValue());
			else if(id=="bboxCenter") BBoxCenter=parser.ParseSFVec3fValue();
			else if(id=="bboxSize") BBoxSize=parser.ParseSFVec3fValue();
			else return false;
			return true;
		}
Exemplo n.º 54
0
 internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
 {
     if (id == "centerOfRotation")
     {
         CenterOfRotation = parser.ParseSFVec3fValue();
     }
     else if (id == "description")
     {
         Description = parser.ParseStringValue();
     }
     else if (id == "fieldOfView")
     {
         if (wasFieldOfView)
         {
             FieldOfView.AddRange(parser.ParseSFFloatOrMFFloatValue());
         }
         else
         {
             FieldOfView = parser.ParseSFFloatOrMFFloatValue();
         }
         wasFieldOfView = true;
     }
     else if (id == "jump")
     {
         Jump = parser.ParseBoolValue();
     }
     else if (id == "orientation")
     {
         Orientation = parser.ParseSFRotationValue();
     }
     else if (id == "position")
     {
         Position = parser.ParseSFVec3fValue();
     }
     else if (id == "retainUserOffsets")
     {
         RetainUserOffsets = parser.ParseBoolValue();
     }
     else
     {
         return(false);
     }
     return(true);
 }
Exemplo n.º 55
0
        internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
        {
            int line = parser.Line;

            if (id == "controlPoint")
            {
                X3DNode node = parser.ParseSFNodeValue();
                if (node != null)
                {
                    ControlPoint = node as X3DCoordinateNode;
                    if (ControlPoint == null)
                    {
                        parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
                    }
                }
            }
            else if (id == "knot")
            {
                Knot.AddRange(parser.ParseSFFloatOrMFFloatValue());
            }
            else if (id == "order")
            {
                Order = parser.ParseIntValue();
            }
            else if (id == "weight" || id == "keyWeight")
            {
                Weight.AddRange(parser.ParseSFFloatOrMFFloatValue());
            }
            else if (id == "dimension")
            {
                Dimension = parser.ParseIntValue();
            }
            else if (id == "fractionAbsolute")
            {
                FractionAbsolute = parser.ParseBoolValue();
            }
            else if (id == "keyValue")
            {
                List <SFVec3f> controlPoints = parser.ParseSFVec3fOrMFVec3fValue();
                if (ControlPoint == null)
                {
                    ControlPoint = new x3dCoordinate();
                }

                x3dCoordinate cp = ControlPoint as x3dCoordinate;
                if (cp != null)
                {
                    cp.Point.AddRange(controlPoints);
                }
            }
            else
            {
                return(false);
            }
            return(true);
        }
Exemplo n.º 56
0
        internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
        {
            int line = parser.Line;

            if (id == "crossSectionCurve")
            {
                X3DNode node = parser.ParseSFNodeValue();
                if (node != null)
                {
                    CrossSectionCurve = node as X3DNurbsControlCurveNode;
                    if (CrossSectionCurve == null)
                    {
                        parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
                    }
                }
            }
            else if (id == "trajectoryCurve")
            {
                X3DNode node = parser.ParseSFNodeValue();
                if (node != null)
                {
                    TrajectoryCurve = node as IX3DNurbsCurveNode;
                    if (TrajectoryCurve == null)
                    {
                        parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
                    }
                }
            }
            else if (id == "ccw")
            {
                CCW = parser.ParseBoolValue();
            }
            else if (id == "solid")
            {
                Solid = parser.ParseBoolValue();
            }
            else
            {
                return(false);
            }
            return(true);
        }
 internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
 {
     if (id == "url")
     {
         URL.AddRange(parser.ParseSFStringOrMFStringValue());
     }
     else if (id == "directOutput")
     {
         DirectOutput = parser.ParseBoolValue();
     }
     else if (id == "mustEvaluate")
     {
         MustEvaluate = parser.ParseBoolValue();
     }
     else
     {
         return(false);
     }
     return(true);
 }
        internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
        {
            int line = parser.Line;

            if (id == "children")
            {
                List <X3DNode> nodes = parser.ParseSFNodeOrMFNodeValue();
                foreach (X3DNode node in nodes)
                {
                    X3DChildNode child = node as X3DChildNode;
                    if (child == null)
                    {
                        parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
                    }
                    else
                    {
                        Children.Add(child);
                    }
                }
            }
            else if (id == "isPickable")
            {
                IsPickable = parser.ParseBoolValue();
            }
            else if (id == "layout")
            {
                X3DNode node = parser.ParseSFNodeValue();
                if (node != null)
                {
                    Layout = node as X3DLayoutNode;
                    if (Layout == null)
                    {
                        parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
                    }
                }
            }
            else if (id == "viewport")
            {
                X3DNode node = parser.ParseSFNodeValue();
                if (node != null)
                {
                    Viewport = node as X3DViewportNode;
                    if (Viewport == null)
                    {
                        parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
                    }
                }
            }
            else
            {
                return(false);
            }
            return(true);
        }
 internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
 {
     if (id == "toggle")
     {
         Toggle = parser.ParseBoolValue();
     }
     else
     {
         return(false);
     }
     return(true);
 }
 internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
 {
     if (id == "autoOffset")
     {
         AutoOffset = parser.ParseBoolValue();
     }
     else if (id == "axisRotation")
     {
         AxisRotation = parser.ParseSFRotationValue();
     }
     else if (id == "description")
     {
         Description = parser.ParseStringValue();
     }
     else if (id == "diskAngle")
     {
         DiskAngle = parser.ParseDoubleValue();
     }
     else if (id == "enabled")
     {
         Enabled = parser.ParseBoolValue();
     }
     else if (id == "maxAngle")
     {
         MaxAngle = parser.ParseDoubleValue();
     }
     else if (id == "minAngle")
     {
         MinAngle = parser.ParseDoubleValue();
     }
     else if (id == "offset")
     {
         Offset = parser.ParseDoubleValue();
     }
     else
     {
         return(false);
     }
     return(true);
 }