void SetupViewport()
        {
            var renderer = GetSubsystem<Renderer>();
            var graphics = GetSubsystem<Graphics>();

            renderer.NumViewports = 2;

            // Set up the front camera viewport
            Viewport viewport = new Viewport(scene, CameraNode.GetComponent<Camera>());
            renderer.SetViewport(0, viewport);

            // Clone the default render path so that we do not interfere with the other viewport, then add
            // bloom and FXAA post process effects to the front viewport. Render path commands can be tagged
            // for example with the effect name to allow easy toggling on and off. We start with the effects
            // disabled.
            var cache = GetSubsystem<ResourceCache>();
            RenderPath effectRenderPath = viewport.GetRenderPath().Clone();
            effectRenderPath.Append(cache.Get<XMLFile>("PostProcess/Bloom.xml"));
            effectRenderPath.Append(cache.Get<XMLFile>("PostProcess/FXAA2.xml"));
            // Make the bloom mixing parameter more pronounced
            effectRenderPath.SetShaderParameter("BloomMix", new Vector2(0.9f, 0.6f));

            effectRenderPath.SetEnabled("Bloom", false);
            effectRenderPath.SetEnabled("FXAA2", false);
            viewport.SetRenderPath(effectRenderPath);

            // Set up the rear camera viewport on top of the front view ("rear view mirror")
            // The viewport index must be greater in that case, otherwise the view would be left behind
            IntRect rect = new IntRect(graphics.Width*2/3, 32, graphics.Width - 32, graphics.Height/3);
            Viewport rearViewport = new Viewport(scene, rearCameraNode.GetComponent<Camera>(), rect);

            renderer.SetViewport(1, rearViewport);
        }
示例#2
0
        void SetupViewport()
        {
            var renderer = GetSubsystem<Renderer>();
            var cache = GetSubsystem<ResourceCache>();

            renderer.SetViewport(0, new Viewport(scene, CameraNode.GetComponent<Camera>()));

            // Create a mathematical plane to represent the water in calculations

            waterPlane = new Plane(waterNode.WorldRotation * new Vector3(0.0f, 1.0f, 0.0f), waterNode.WorldPosition);
            // Create a downward biased plane for reflection view clipping. Biasing is necessary to avoid too aggressive clipping
            waterClipPlane = new Plane(waterNode.WorldRotation * new Vector3(0.0f, 1.0f, 0.0f), waterNode.WorldPosition - new Vector3(0.0f, 0.1f, 0.0f));

            // Create camera for water reflection
            // It will have the same farclip and position as the main viewport camera, but uses a reflection plane to modify
            // its position when rendering
            reflectionCameraNode = CameraNode.CreateChild();
            var reflectionCamera = reflectionCameraNode.CreateComponent<Camera>();
            reflectionCamera.FarClip = 750.0f;
            reflectionCamera.ViewMask= 0x7fffffff; // Hide objects with only bit 31 in the viewmask (the water plane)
            reflectionCamera.AutoAspectRatio = false;
            reflectionCamera.UseReflection = true;
            reflectionCamera.ReflectionPlane = waterPlane;
            reflectionCamera.UseClipping = true; // Enable clipping of geometry behind water plane
            reflectionCamera.ClipPlane = waterClipPlane;
            // The water reflection texture is rectangular. Set reflection camera aspect ratio to match
            reflectionCamera.AspectRatio = (float)graphics.Width / graphics.Height;
            // View override flags could be used to optimize reflection rendering. For example disable shadows
            //reflectionCamera.ViewOverrideFlags = ViewOverrideFlags.DisableShadows;

            // Create a texture and setup viewport for water reflection. Assign the reflection texture to the diffuse
            // texture unit of the water material
            int texSize = 1024;
            Texture2D renderTexture = new Texture2D();
            renderTexture.SetSize(texSize, texSize, Graphics.GetRGBFormat(), TextureUsage.TEXTURE_RENDERTARGET);
            renderTexture.FilterMode = TextureFilterMode.FILTER_BILINEAR;
            RenderSurface surface = renderTexture.RenderSurface;
            var rttViewport = new Viewport(scene, reflectionCamera);
            surface.SetViewport(0, rttViewport);
            var waterMat = cache.Get<Material>("Materials/Water.xml");
            waterMat.SetTexture(TextureUnit.TU_DIFFUSE, renderTexture);
        }
        void CreateScene()
        {
            var cache = GetSubsystem<ResourceCache>();

            {
                rttScene = new Scene();
                // Create octree, use default volume (-1000, -1000, -1000) to (1000, 1000, 1000)
                rttScene.CreateComponent<Octree>();

                // Create a Zone for ambient light & fog control
                Node zoneNode = rttScene.CreateChild("Zone");
                Zone zone = zoneNode.CreateComponent<Zone>();
                // Set same volume as the Octree, set a close bluish fog and some ambient light
                zone.SetBoundingBox(new BoundingBox(-1000.0f, 1000.0f));
                zone.AmbientColor = new Color(0.05f, 0.1f, 0.15f);
                zone.FogColor = new Color(0.1f, 0.2f, 0.3f);
                zone.FogStart = 10.0f;
                zone.FogEnd = 100.0f;

                // Create randomly positioned and oriented box StaticModels in the scene
                const uint numObjects = 2000;
                for (uint i = 0; i < numObjects; ++i)
                {
                    Node boxNode = rttScene.CreateChild("Box");
                    boxNode.Position = new Vector3(NextRandom(200.0f) - 100.0f, NextRandom(200.0f) - 100.0f,
                        NextRandom(200.0f) - 100.0f);
                    // Orient using random pitch, yaw and roll Euler angles
                    boxNode.Rotation = new Quaternion(NextRandom(360.0f), NextRandom(360.0f), NextRandom(360.0f));
                    StaticModel boxObject = boxNode.CreateComponent<StaticModel>();
                    boxObject.Model = cache.Get<Model>("Models/Box.mdl");
                    boxObject.SetMaterial(cache.Get<Material>("Materials/Stone.xml"));

                    // Add our custom Rotator component which will rotate the scene node each frame, when the scene sends its update event.
                    // Simply set same rotation speed for all objects
                    Rotator rotator = new Rotator();
                    boxNode.AddComponent(rotator);
                    rotator.SetRotationSpeed(new Vector3(10.0f, 20.0f, 30.0f));
                }

                // Create a camera for the render-to-texture scene. Simply leave it at the world origin and let it observe the scene
                rttCameraNode = rttScene.CreateChild("Camera");
                Camera camera = rttCameraNode.CreateComponent<Camera>();
                camera.FarClip = 100.0f;

                // Create a point light to the camera scene node
                Light light = rttCameraNode.CreateComponent<Light>();
                light.LightType = LightType.LIGHT_POINT;
                light.Range = 30.0f;
            }

            {
                // Create the scene in which we move around

                scene = new Scene();

                // Create octree, use also default volume (-1000, -1000, -1000) to (1000, 1000, 1000)
                scene.CreateComponent<Octree>();

                // Create a Zone component for ambient lighting & fog control
                Node zoneNode = scene.CreateChild("Zone");
                Zone zone = zoneNode.CreateComponent<Zone>();
                zone.SetBoundingBox(new BoundingBox(-1000.0f, 1000.0f));
                zone.AmbientColor = new Color(0.1f, 0.1f, 0.1f);
                zone.FogStart = 100.0f;
                zone.FogEnd = 300.0f;

                // Create a directional light without shadows
                Node lightNode = scene.CreateChild("DirectionalLight");
                lightNode.SetDirection(new Vector3(0.5f, -1.0f, 0.5f));
                Light light = lightNode.CreateComponent<Light>();
                light.LightType = LightType.LIGHT_DIRECTIONAL;
                light.Color = new Color(0.2f, 0.2f, 0.2f);
                light.SpecularIntensity = 1.0f;

                // Create a "floor" consisting of several tiles
                for (int y = -5; y <= 5; ++y)
                {
                    for (int x = -5; x <= 5; ++x)
                    {
                        Node floorNode = scene.CreateChild("FloorTile");
                        floorNode.Position = new Vector3(x*20.5f, -0.5f, y*20.5f);
                        floorNode.Scale = new Vector3(20.0f, 1.0f, 20.0f);
                        StaticModel floorObject = floorNode.CreateComponent<StaticModel>();
                        floorObject.Model = cache.Get<Model>("Models/Box.mdl");
                        floorObject.SetMaterial(cache.Get<Material>("Materials/Stone.xml"));
                    }
                }

                // Create a "screen" like object for viewing the second scene. Construct it from two StaticModels, a box for the frame
                // and a plane for the actual view
                {
                    Node boxNode = scene.CreateChild("ScreenBox");
                    boxNode.Position = new Vector3(0.0f, 10.0f, 0.0f);
                    boxNode.Scale = new Vector3(21.0f, 16.0f, 0.5f);
                    StaticModel boxObject = boxNode.CreateComponent<StaticModel>();
                    boxObject.Model = cache.Get<Model>("Models/Box.mdl");
                    boxObject.SetMaterial(cache.Get<Material>("Materials/Stone.xml"));

                    Node screenNode = scene.CreateChild("Screen");
                    screenNode.Position = new Vector3(0.0f, 10.0f, -0.27f);
                    screenNode.Rotation = new Quaternion(-90.0f, 0.0f, 0.0f);
                    screenNode.Scale = new Vector3(20.0f, 0.0f, 15.0f);
                    StaticModel screenObject = screenNode.CreateComponent<StaticModel>();
                    screenObject.Model = cache.Get<Model>("Models/Plane.mdl");

                    // Create a renderable texture (1024x768, RGB format), enable bilinear filtering on it
                    Texture2D renderTexture = new Texture2D();
                    renderTexture.SetSize(1024, 768, Graphics.GetRGBFormat(), TextureUsage.TEXTURE_RENDERTARGET);
                    renderTexture.FilterMode = TextureFilterMode.FILTER_BILINEAR;

                    // Create a new material from scratch, use the diffuse unlit technique, assign the render texture
                    // as its diffuse texture, then assign the material to the screen plane object
                    Material renderMaterial = new Material();
                    renderMaterial.SetTechnique(0, cache.Get<Technique>("Techniques/DiffUnlit.xml"), 0, 0);
                    renderMaterial.SetTexture(TextureUnit.TU_DIFFUSE, renderTexture);
                    screenObject.SetMaterial(renderMaterial);

                    // Get the texture's RenderSurface object (exists when the texture has been created in rendertarget mode)
                    // and define the viewport for rendering the second scene, similarly as how backbuffer viewports are defined
                    // to the Renderer subsystem. By default the texture viewport will be updated when the texture is visible
                    // in the main view
                    RenderSurface surface = renderTexture.RenderSurface;
                    Viewport rttViewport = new Viewport(rttScene, rttCameraNode.GetComponent<Camera>());
                    surface.SetViewport(0, rttViewport);
                }

                // Create the camera. Limit far clip distance to match the fog
                CameraNode = scene.CreateChild("Camera");
                var camera = CameraNode.CreateComponent<Camera>();
                camera.FarClip = 300.0f;
                // Set an initial position for the camera scene node above the plane
                CameraNode.Position = new Vector3(0.0f, 7.0f, -30.0f);
            }
        }
示例#4
0
        void CreateScene()
        {
            scene = new Scene();
            scene.CreateComponent<Octree>();
            scene.CreateComponent<DebugRenderer>();
            PhysicsWorld2D physicsWorld = scene.CreateComponent<PhysicsWorld2D>(); // Create 2D physics world component
            physicsWorld.DrawJoint = true; // Display the joints (Note that DrawDebugGeometry() must be set to true to acually draw the joints)
            drawDebug = true; // Set DrawDebugGeometry() to true

            // Create camera
            CameraNode = scene.CreateChild("Camera");
            // Set camera's position
            CameraNode.Position = (new Vector3(0.0f, 0.0f, 0.0f)); // Note that Z setting is discarded; use camera.zoom instead (see MoveCamera() below for example)

            camera = CameraNode.CreateComponent<Camera>();
            camera.Orthographic = true;

            var graphics = GetSubsystem<Graphics>();

            camera.OrthoSize = (float)graphics.Height * PixelSize;
            camera.Zoom = 1.2f * Math.Min((float)graphics.Width / 1280.0f, (float)graphics.Height / 800.0f); // Set zoom according to user's resolution to ensure full visibility (initial zoom (1.2) is set for full visibility at 1280x800 resolution)

            // Set up a viewport to the Renderer subsystem so that the 3D scene can be seen
            Viewport viewport = new Viewport(scene, camera);
            Renderer renderer = GetSubsystem<Renderer>();
            renderer.SetViewport(0, viewport);

            Zone zone = renderer.DefaultZone;
            zone.FogColor = (new Color(0.1f, 0.1f, 0.1f)); // Set background color for the scene

            // Create 4x3 grid
            for (uint i = 0; i < 5; ++i)
            {
                Node edgeNode = scene.CreateChild("VerticalEdge");
                RigidBody2D edgeBody = edgeNode.CreateComponent<RigidBody2D>();
                if (dummyBody == null)
                    dummyBody = edgeBody; // Mark first edge as dummy body (used by mouse pick)
                CollisionEdge2D edgeShape = edgeNode.CreateComponent<CollisionEdge2D>();
                edgeShape.SetVertices(new Vector2(i * 2.5f - 5.0f, -3.0f), new Vector2(i * 2.5f - 5.0f, 3.0f));
                edgeShape.Friction = 0.5f; // Set friction
            }

            for (uint j = 0; j < 4; ++j)
            {
                Node edgeNode = scene.CreateChild("HorizontalEdge");
                /*RigidBody2D edgeBody = */
                edgeNode.CreateComponent<RigidBody2D>();
                CollisionEdge2D edgeShape = edgeNode.CreateComponent<CollisionEdge2D>();
                edgeShape.SetVertices(new Vector2(-5.0f, j * 2.0f - 3.0f), new Vector2(5.0f, j * 2.0f - 3.0f));
                edgeShape.Friction = 0.5f; // Set friction
            }

            var cache = GetSubsystem<ResourceCache>();

            // Create a box (will be cloned later)
            Node box = scene.CreateChild("Box");
            box.Position = (new Vector3(0.8f, -2.0f, 0.0f));
            StaticSprite2D boxSprite = box.CreateComponent<StaticSprite2D>();
            boxSprite.Sprite = cache.Get<Sprite2D>("Urho2D/Box.png");
            RigidBody2D boxBody = box.CreateComponent<RigidBody2D>();
            boxBody.BodyType = BodyType2D.BT_DYNAMIC;
            boxBody.LinearDamping = 0.0f;
            boxBody.AngularDamping = 0.0f;
            CollisionBox2D shape = box.CreateComponent<CollisionBox2D>(); // Create box shape
            shape.Size = new Vector2(0.32f, 0.32f); // Set size
            shape.Density = 1.0f; // Set shape density (kilograms per meter squared)
            shape.Friction = 0.5f; // Set friction
            shape.Restitution = 0.1f; // Set restitution (slight bounce)

            // Create a ball (will be cloned later)
            Node ball = scene.CreateChild("Ball");
            ball.Position = (new Vector3(1.8f, -2.0f, 0.0f));
            StaticSprite2D ballSprite = ball.CreateComponent<StaticSprite2D>();
            ballSprite.Sprite = cache.Get<Sprite2D>("Urho2D/Ball.png");
            RigidBody2D ballBody = ball.CreateComponent<RigidBody2D>();
            ballBody.BodyType = BodyType2D.BT_DYNAMIC;
            ballBody.LinearDamping = 0.0f;
            ballBody.AngularDamping = 0.0f;
            CollisionCircle2D ballShape = ball.CreateComponent<CollisionCircle2D>(); // Create circle shape
            ballShape.Radius = 0.16f; // Set radius
            ballShape.Density = 1.0f; // Set shape density (kilograms per meter squared)
            ballShape.Friction = 0.5f; // Set friction
            ballShape.Restitution = 0.6f; // Set restitution: make it bounce

            // Create a polygon
            Node polygon = scene.CreateChild("Polygon");
            polygon.Position = (new Vector3(1.6f, -2.0f, 0.0f));
            polygon.SetScale(0.7f);
            StaticSprite2D polygonSprite = polygon.CreateComponent<StaticSprite2D>();
            polygonSprite.Sprite = cache.Get<Sprite2D>("Urho2D/Aster.png");
            RigidBody2D polygonBody = polygon.CreateComponent<RigidBody2D>();
            polygonBody.BodyType = BodyType2D.BT_DYNAMIC;
            CollisionPolygon2D polygonShape = polygon.CreateComponent<CollisionPolygon2D>();
            polygonShape.VertexCount = 6; // Set number of vertices (mandatory when using SetVertex())
            polygonShape.SetVertex(0, new Vector2(-0.8f, -0.3f));
            polygonShape.SetVertex(1, new Vector2(0.5f, -0.8f));
            polygonShape.SetVertex(2, new Vector2(0.8f, -0.3f));
            polygonShape.SetVertex(3, new Vector2(0.8f, 0.5f));
            polygonShape.SetVertex(4, new Vector2(0.5f, 0.9f));
            polygonShape.SetVertex(5, new Vector2(-0.5f, 0.7f));
            polygonShape.Density = 1.0f; // Set shape density (kilograms per meter squared)
            polygonShape.Friction = 0.3f; // Set friction
            polygonShape.Restitution = 0.0f; // Set restitution (no bounce)

            // Create a ConstraintDistance2D
            CreateFlag("ConstraintDistance2D", -4.97f, 3.0f); // Display Text3D flag
            Node boxDistanceNode = box.Clone(CreateMode.REPLICATED);
            Node ballDistanceNode = ball.Clone(CreateMode.REPLICATED);
            RigidBody2D ballDistanceBody = ballDistanceNode.GetComponent<RigidBody2D>();
            boxDistanceNode.Position = (new Vector3(-4.5f, 2.0f, 0.0f));
            ballDistanceNode.Position = (new Vector3(-3.0f, 2.0f, 0.0f));

            ConstraintDistance2D constraintDistance = boxDistanceNode.CreateComponent<ConstraintDistance2D>(); // Apply ConstraintDistance2D to box
            constraintDistance.OtherBody = ballDistanceBody; // Constrain ball to box
            constraintDistance.OwnerBodyAnchor = boxDistanceNode.Position2D;
            constraintDistance.OtherBodyAnchor = ballDistanceNode.Position2D;
            // Make the constraint soft (comment to make it rigid, which is its basic behavior)
            constraintDistance.FrequencyHz = 4.0f;
            constraintDistance.DampingRatio = 0.5f;

            // Create a ConstraintFriction2D ********** Not functional. From Box2d samples it seems that 2 anchors are required, Urho2D only provides 1, needs investigation ***********
            CreateFlag("ConstraintFriction2D", 0.03f, 1.0f); // Display Text3D flag
            Node boxFrictionNode = box.Clone(CreateMode.REPLICATED);
            Node ballFrictionNode = ball.Clone(CreateMode.REPLICATED);
            boxFrictionNode.Position = (new Vector3(0.5f, 0.0f, 0.0f));
            ballFrictionNode.Position = (new Vector3(1.5f, 0.0f, 0.0f));

            ConstraintFriction2D constraintFriction = boxFrictionNode.CreateComponent<ConstraintFriction2D>(); // Apply ConstraintDistance2D to box
            constraintFriction.OtherBody = ballFrictionNode.GetComponent<RigidBody2D>(); // Constraint ball to box

            // Create a ConstraintGear2D
            CreateFlag("ConstraintGear2D", -4.97f, -1.0f); // Display Text3D flag
            Node baseNode = box.Clone(CreateMode.REPLICATED);
            RigidBody2D tempBody = baseNode.GetComponent<RigidBody2D>(); // Get body to make it static
            tempBody.BodyType = BodyType2D.BT_STATIC;
            baseNode.Position = (new Vector3(-3.7f, -2.5f, 0.0f));
            Node ball1Node = ball.Clone(CreateMode.REPLICATED);
            ball1Node.Position = (new Vector3(-4.5f, -2.0f, 0.0f));
            RigidBody2D ball1Body = ball1Node.GetComponent<RigidBody2D>();
            Node ball2Node = ball.Clone(CreateMode.REPLICATED);
            ball2Node.Position = (new Vector3(-3.0f, -2.0f, 0.0f));
            RigidBody2D ball2Body = ball2Node.GetComponent<RigidBody2D>();

            ConstraintRevolute2D gear1 = baseNode.CreateComponent<ConstraintRevolute2D>(); // Apply constraint to baseBox
            gear1.OtherBody = ball1Body; // Constrain ball1 to baseBox
            gear1.Anchor = ball1Node.Position2D;
            ConstraintRevolute2D gear2 = baseNode.CreateComponent<ConstraintRevolute2D>(); // Apply constraint to baseBox
            gear2.OtherBody = ball2Body; // Constrain ball2 to baseBox
            gear2.Anchor = ball2Node.Position2D;

            ConstraintGear2D constraintGear = ball1Node.CreateComponent<ConstraintGear2D>(); // Apply constraint to ball1
            constraintGear.OtherBody = ball2Body; // Constrain ball2 to ball1
            constraintGear.OwnerConstraint = gear1;
            constraintGear.OtherConstraint = gear2;
            constraintGear.Ratio = 1.0f;

            ball1Body.ApplyAngularImpulse(0.015f, true); // Animate

            // Create a vehicle from a compound of 2 ConstraintWheel2Ds
            CreateFlag("ConstraintWheel2Ds compound", -2.45f, -1.0f); // Display Text3D flag
            Node car = box.Clone(CreateMode.REPLICATED);
            car.Scale = new Vector3(4.0f, 1.0f, 0.0f);
            car.Position = (new Vector3(-1.2f, -2.3f, 0.0f));
            StaticSprite2D tempSprite = car.GetComponent<StaticSprite2D>(); // Get car Sprite in order to draw it on top
            tempSprite.OrderInLayer = 0; // Draw car on top of the wheels (set to -1 to draw below)
            Node ball1WheelNode = ball.Clone(CreateMode.REPLICATED);
            ball1WheelNode.Position = (new Vector3(-1.6f, -2.5f, 0.0f));
            Node ball2WheelNode = ball.Clone(CreateMode.REPLICATED);
            ball2WheelNode.Position = (new Vector3(-0.8f, -2.5f, 0.0f));

            ConstraintWheel2D wheel1 = car.CreateComponent<ConstraintWheel2D>();
            wheel1.OtherBody = ball1WheelNode.GetComponent<RigidBody2D>();
            wheel1.Anchor = ball1WheelNode.Position2D;
            wheel1.Axis = new Vector2(0.0f, 1.0f);
            wheel1.MaxMotorTorque = 20.0f;
            wheel1.FrequencyHz = 4.0f;
            wheel1.DampingRatio = 0.4f;

            ConstraintWheel2D wheel2 = car.CreateComponent<ConstraintWheel2D>();
            wheel2.OtherBody = ball2WheelNode.GetComponent<RigidBody2D>();
            wheel2.Anchor = ball2WheelNode.Position2D;
            wheel2.Axis = new Vector2(0.0f, 1.0f);
            wheel2.MaxMotorTorque = 10.0f;
            wheel2.FrequencyHz = 4.0f;
            wheel2.DampingRatio = 0.4f;

            // ConstraintMotor2D
            CreateFlag("ConstraintMotor2D", 2.53f, -1.0f); // Display Text3D flag
            Node boxMotorNode = box.Clone(CreateMode.REPLICATED);
            tempBody = boxMotorNode.GetComponent<RigidBody2D>(); // Get body to make it static
            tempBody.BodyType = BodyType2D.BT_STATIC;
            Node ballMotorNode = ball.Clone(CreateMode.REPLICATED);
            boxMotorNode.Position = (new Vector3(3.8f, -2.1f, 0.0f));
            ballMotorNode.Position = (new Vector3(3.8f, -1.5f, 0.0f));

            ConstraintMotor2D constraintMotor = boxMotorNode.CreateComponent<ConstraintMotor2D>();
            constraintMotor.OtherBody = ballMotorNode.GetComponent<RigidBody2D>(); // Constrain ball to box
            constraintMotor.LinearOffset = new Vector2(0.0f, 0.8f); // Set ballNode position relative to boxNode position = (0,0)
            constraintMotor.AngularOffset = 0.1f;
            constraintMotor.MaxForce = 5.0f;
            constraintMotor.MaxTorque = 10.0f;
            constraintMotor.CorrectionFactor = 1.0f;
            constraintMotor.CollideConnected = true; // doesn't work

            // ConstraintMouse2D is demonstrated in HandleMouseButtonDown() function. It is used to "grasp" the sprites with the mouse.
            CreateFlag("ConstraintMouse2D", 0.03f, -1.0f); // Display Text3D flag

            // Create a ConstraintPrismatic2D
            CreateFlag("ConstraintPrismatic2D", 2.53f, 3.0f); // Display Text3D flag
            Node boxPrismaticNode = box.Clone(CreateMode.REPLICATED);
            tempBody = boxPrismaticNode.GetComponent<RigidBody2D>(); // Get body to make it static
            tempBody.BodyType = BodyType2D.BT_STATIC;
            Node ballPrismaticNode = ball.Clone(CreateMode.REPLICATED);
            boxPrismaticNode.Position = new Vector3(3.3f, 2.5f, 0.0f);
            ballPrismaticNode.Position = new Vector3(4.3f, 2.0f, 0.0f);

            ConstraintPrismatic2D constraintPrismatic = boxPrismaticNode.CreateComponent<ConstraintPrismatic2D>();
            constraintPrismatic.OtherBody = ballPrismaticNode.GetComponent<RigidBody2D>(); // Constrain ball to box
            constraintPrismatic.Axis = new Vector2(1.0f, 1.0f); // Slide from [0,0] to [1,1]
            constraintPrismatic.Anchor = new Vector2(4.0f, 2.0f);
            constraintPrismatic.LowerTranslation = -1.0f;
            constraintPrismatic.UpperTranslation = 0.5f;
            constraintPrismatic.EnableLimit = true;
            constraintPrismatic.MaxMotorForce = 1.0f;
            constraintPrismatic.MotorSpeed = 0.0f;

            // ConstraintPulley2D
            CreateFlag("ConstraintPulley2D", 0.03f, 3.0f); // Display Text3D flag
            Node boxPulleyNode = box.Clone(CreateMode.REPLICATED);
            Node ballPulleyNode = ball.Clone(CreateMode.REPLICATED);
            boxPulleyNode.Position = (new Vector3(0.5f, 2.0f, 0.0f));
            ballPulleyNode.Position = (new Vector3(2.0f, 2.0f, 0.0f));

            ConstraintPulley2D constraintPulley = boxPulleyNode.CreateComponent<ConstraintPulley2D>(); // Apply constraint to box
            constraintPulley.OtherBody = ballPulleyNode.GetComponent<RigidBody2D>(); // Constrain ball to box
            constraintPulley.OwnerBodyAnchor = boxPulleyNode.Position2D;
            constraintPulley.OtherBodyAnchor = ballPulleyNode.Position2D;
            constraintPulley.OwnerBodyGroundAnchor = boxPulleyNode.Position2D + new Vector2(0.0f, 1.0f);
            constraintPulley.OtherBodyGroundAnchor = ballPulleyNode.Position2D + new Vector2(0.0f, 1.0f);
            constraintPulley.Ratio = 1.0f; // Weight ratio between ownerBody and otherBody

            // Create a ConstraintRevolute2D
            CreateFlag("ConstraintRevolute2D", -2.45f, 3.0f); // Display Text3D flag
            Node boxRevoluteNode = box.Clone(CreateMode.REPLICATED);
            tempBody = boxRevoluteNode.GetComponent<RigidBody2D>(); // Get body to make it static
            tempBody.BodyType = BodyType2D.BT_STATIC;
            Node ballRevoluteNode = ball.Clone(CreateMode.REPLICATED);
            boxRevoluteNode.Position = (new Vector3(-2.0f, 1.5f, 0.0f));
            ballRevoluteNode.Position = (new Vector3(-1.0f, 2.0f, 0.0f));

            ConstraintRevolute2D constraintRevolute = boxRevoluteNode.CreateComponent<ConstraintRevolute2D>(); // Apply constraint to box
            constraintRevolute.OtherBody = ballRevoluteNode.GetComponent<RigidBody2D>(); // Constrain ball to box
            constraintRevolute.Anchor = new Vector2(-1.0f, 1.5f);
            constraintRevolute.LowerAngle = -1.0f; // In radians
            constraintRevolute.UpperAngle = 0.5f; // In radians
            constraintRevolute.EnableLimit = true;
            constraintRevolute.MaxMotorTorque = 10.0f;
            constraintRevolute.MotorSpeed = 0.0f;
            constraintRevolute.EnableMotor = true;

            // Create a ConstraintRope2D
            CreateFlag("ConstraintRope2D", -4.97f, 1.0f); // Display Text3D flag
            Node boxRopeNode = box.Clone(CreateMode.REPLICATED);
            tempBody = boxRopeNode.GetComponent<RigidBody2D>();
            tempBody.BodyType = BodyType2D.BT_STATIC;
            Node ballRopeNode = ball.Clone(CreateMode.REPLICATED);
            boxRopeNode.Position = (new Vector3(-3.7f, 0.7f, 0.0f));
            ballRopeNode.Position = (new Vector3(-4.5f, 0.0f, 0.0f));

            ConstraintRope2D constraintRope = boxRopeNode.CreateComponent<ConstraintRope2D>();
            constraintRope.OtherBody = ballRopeNode.GetComponent<RigidBody2D>(); // Constrain ball to box
            constraintRope.OwnerBodyAnchor = new Vector2(0.0f, -0.5f); // Offset from box (OwnerBody) : the rope is rigid from OwnerBody center to this ownerBodyAnchor
            constraintRope.MaxLength = 0.9f; // Rope length
            constraintRope.CollideConnected = true;

            // Create a ConstraintWeld2D
            CreateFlag("ConstraintWeld2D", -2.45f, 1.0f); // Display Text3D flag
            Node boxWeldNode = box.Clone(CreateMode.REPLICATED);
            Node ballWeldNode = ball.Clone(CreateMode.REPLICATED);
            boxWeldNode.Position = (new Vector3(-0.5f, 0.0f, 0.0f));
            ballWeldNode.Position = (new Vector3(-2.0f, 0.0f, 0.0f));

            ConstraintWeld2D constraintWeld = boxWeldNode.CreateComponent<ConstraintWeld2D>();
            constraintWeld.OtherBody = ballWeldNode.GetComponent<RigidBody2D>(); // Constrain ball to box
            constraintWeld.Anchor = boxWeldNode.Position2D;
            constraintWeld.FrequencyHz = 4.0f;
            constraintWeld.DampingRatio = 0.5f;

            // Create a ConstraintWheel2D
            CreateFlag("ConstraintWheel2D", 2.53f, 1.0f); // Display Text3D flag
            Node boxWheelNode = box.Clone(CreateMode.REPLICATED);
            Node ballWheelNode = ball.Clone(CreateMode.REPLICATED);
            boxWheelNode.Position = (new Vector3(3.8f, 0.0f, 0.0f));
            ballWheelNode.Position = (new Vector3(3.8f, 0.9f, 0.0f));

            ConstraintWheel2D constraintWheel = boxWheelNode.CreateComponent<ConstraintWheel2D>();
            constraintWheel.OtherBody = ballWheelNode.GetComponent<RigidBody2D>(); // Constrain ball to box
            constraintWheel.Anchor = ballWheelNode.Position2D;
            constraintWheel.Axis = new Vector2(0.0f, 1.0f);
            constraintWheel.EnableMotor = true;
            constraintWheel.MaxMotorTorque = 1.0f;
            constraintWheel.MotorSpeed = 0.0f;
            constraintWheel.FrequencyHz = 4.0f;
            constraintWheel.DampingRatio = 0.5f;
            constraintWheel.CollideConnected = true; // doesn't work
        }