示例#1
0
        private void ArrangeAndDecorateLeaf(int nodeIndex, IStoryGraph sg)
        {
            var aStory = sg.Aspects[nodeIndex];
            var node   = sg.NodeObjects[nodeIndex];

            var wallVisuals    = CorridorWall(Quaternion.Identity, Vector3.UnitY * FrustumDistance);
            var frustumVisuals = ModelVisualElement.New()
                                 .SetModel(frustumModel)
                                 .SetMaterial(frustumMaterial)
                                 .SetRenderState(StandardRenderState.New()
                                                 .SetCullFace(CullFace.Back)
                                                 .FromGlobalCache())
                                 .SetTransform(new Transform(1, Quaternion.RotationX(-MathHelper.PiOver2), Vector3.Zero));
            var visuals = new [] { frustumVisuals, wallVisuals };

            var viewpointProps = new TargetedControlledCamera.Props
            {
                Target      = Vector3.Zero,
                Distance    = FrustumDistance,
                FieldOfView = MathHelper.PiOver4,
                ZNear       = 0.1f * FrustumDistance,
                ZFar        = 100.0f * FrustumDistance
            };

            var transform2D = new Transform(2, Quaternion.RotationX(-MathHelper.PiOver2), FrustumDistance * Vector3.UnitY);

            aStory.SetDynamicParts(new StoryNodeDynamicParts
            {
                DefaultViewpointMechanism = new WallDefaultViewpointMechanismZ(node, viewpointProps),
                Hittable       = GetHittableComponent(node, transform2D),
                VisualElements = visuals
            });
        }
示例#2
0
        private void ArrangeAndDecorateIntermediate(int nodeIndex, IStoryGraph sg)
        {
            var aStory           = sg.Aspects[nodeIndex];
            var node             = sg.NodeObjects[nodeIndex];
            var abstractChildren = sg.Children[nodeIndex];
            var numChildren      = abstractChildren.Count;

            var forward      = Vector3.UnitY;
            var right        = Vector3.UnitX;
            var rightWallPos = forward * exitHalfLength + right * corridorHalfWidth;
            var rightWallRot = Quaternion.RotationZ(MathHelper.PiOver2);
            var leftWallPos  = forward * exitHalfLength - right * corridorHalfWidth;
            var leftWallRot  = Quaternion.RotationZ(-MathHelper.PiOver2);

            var visuals = new List <IVisualElement>();

            // right exit wall
            visuals.Add(ExitWall(rightWallRot, rightWallPos));

            // left exit wall
            visuals.Add(ExitWall(leftWallRot, leftWallPos));

            var viewpointProps = new TargetedControlledCamera.Props
            {
                Target      = Vector3.Zero,
                Distance    = FrustumDistance,
                FieldOfView = MathHelper.PiOver4,
                ZNear       = 0.1f * FrustumDistance,
                ZFar        = 100.0f * FrustumDistance
            };

            var i = 0;
            //var numSegments = adaptiveLayout.AdaptiveChildren.Count * 2 - 1;
            var numSegments = numChildren % 2 == 0
                ? numChildren + 1
                : numChildren;

            while (i < numSegments)
            {
                //var childIndex = i / 2;
                var childIndex = i;

                var     exitOffset     = 2 * exitHalfLength;
                var     neighborOffset = 2 * corridorHalfWidth;
                Vector3 childForward;

                Vector3    position;
                Quaternion rotation;

                if (i < numSegments / 2)
                {
                    childForward = right;
                    position     =
                        forward * (exitOffset + neighborOffset * i + corridorHalfWidth) +
                        childForward * corridorHalfWidth;
                    rotation = rightWallRot;
                }
                else if (i > numSegments / 2)
                {
                    childForward = -right;
                    var numNeighborsAfter = numSegments - i - 1;
                    position =
                        forward * (exitOffset + neighborOffset * numNeighborsAfter + corridorHalfWidth) +
                        childForward * corridorHalfWidth;
                    rotation = leftWallRot;
                }
                else
                {
                    childForward = forward;
                    position     = forward * (exitOffset + neighborOffset * i);
                    rotation     = Quaternion.Identity;
                }

                if (i < numChildren)
                {
                    var adaptiveChild = abstractChildren[childIndex];
                    if (abstractChildren.Any())
                    {
                        sg.NodeObjects[adaptiveChild].Transform = new Transform(1, rotation, position);
                        ArrangeAndDecorateIntermediate(adaptiveChild, sg);
                    }
                    else
                    {
                        sg.NodeObjects[adaptiveChild].Transform = new Transform(1, rotation, position - childForward * FrustumDistance);
                        ArrangeAndDecorateLeaf(adaptiveChild, sg);
                    }
                }
                else
                {
                    visuals.Add(CorridorWall(rotation, position));
                }

                i++;
            }

            aStory.SetDynamicParts(new StoryNodeDynamicParts
            {
                DefaultViewpointMechanism = new WallDefaultViewpointMechanismZ(node, viewpointProps),
                Hittable       = new DummyHittable(),
                VisualElements = visuals
            });
        }
示例#3
0
 public WallDefaultViewpointMechanismZ(ISceneNode node, TargetedControlledCamera.Props props)
 {
     this.node   = node;
     this.props  = props;
     FixedCamera = CreateControlledViewpoint();
 }