Создание графа сцены для XNA

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

public class SceneNodeCollection : ICollection<SceneNode>
{
    /// Тут простая реализация коллекции
}
 
 
public interface IController
{
    void UpdateSceneNode(SceneNode node, GameTime gameTime);
}
 
 
public class SceneNode
{
 
    // Поля
    SceneNodeCollection children = new SceneNodeCollection();
    Vector3 position = Vector3.Zero;
    Vector3 offset = Vector3.Zero;
    Quaternion rotation = Quaternion.Identity;
    bool visible = true;
    Matrix absoluteTransform = Matrix.Identity;
    IController controller;
 
 
    // Свойства
 
    public SceneNodeCollection Children
    {
        get { return children; }
    }
 
    public Vector3 Position
    {
        get { return position; }
        set { position = value; }
    }
 
    public Vector3 Offset
    {
        get { return offset; }
        set { offset = value; }
    }
 
    public Quaternion Rotation
    {
        get { return rotation; }
        set { rotation = value; }
    }
 
    public bool Visible
    {
        get { return visible; }
        set { visible = value; }
    }
 
    public BoundingSphere BoundingSphere
    {
        get { return GetBoundingSphere(); }
    }
 
    public Matrix AbsoluteTransform
    {
        get { return absoluteTransform; }
        set { absoluteTransform = value; }
    }
 
    public IController Controller
    {
        get { return controller; }
        set { controller = value; }
    }
 
    // Конструктор по умолчанию
    public SceneNode()
    {
    }
 
    //Методы
    protected virtual BoundingSphere GetBoundingSphere()
    {
        return new BoundingSphere(center, 0);
    }
 
    public virtual void Update(SceneGraph sceneGraph)
    {
        if (controller != null)
            controller.UpdateSceneNode(this, sceneGraph.GameTime);
    }
 
    public virtual void Draw(SceneGraph sceneGraph)
    {
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

public class ModelSceneNode : SceneNode
{
    // Поля
    Model model;
    BoundingSphere modelSphere;
 
    // Свойства
    public Model Model
    {
        get { return model; }
        set
        {
            model = value;
 
            if (model == null)
                modelSphere = new BoundingSphere(Center, 0);
            else
                CalculateBoundingSphere();
        }
    }
 
    // Конструкторы
    public ModelSceneNode()
    {
    }
 
    public ModelSceneNode(Model model)
    {
        this.model = model;
        CalculateBoundingSphere();
    }
 
    // Методы
    private void CalculateBoundingSphere()
    {
        //Расчет BoundingSphere для модели
        modelSphere = new BoundingSphere();
 
        foreach (ModelMesh mesh in model.Meshes)
        {
            modelSphere = Microsoft.Xna.Framework.BoundingSphere.CreateMerged(
                                modelSphere,
                                model.Meshes[0].BoundingSphere);
        }
    }
 
    protected override BoundingSphere GetBoundingSphere()
    {
        return modelSphere;
    }
 
    public override void Draw(SceneGraph sceneGraph)
    {
        if (sceneGraph.Camera != null)
        {
            if (model != null)
            {
                // Копирование иерархии трансформаций модели
                Matrix[] transforms = new Matrix[model.Bones.Count];
                model.CopyAbsoluteBoneTransformsTo(transforms);
 
                // отрисовка кождого меша из модели
                foreach (ModelMesh mesh in model.Meshes)
                {
                    foreach (Effect effect in mesh.Effects)
                    {
                        BasicEffect basicEffect = effect as BasicEffect;
 
                        if (basicEffect == null)
                        {
                            throw new NotSupportedException(
                                    "Only the BasicEffect is supported in a model.");
                        }
 
                        //Установка матриц
                        basicEffect.World = transforms[mesh.ParentBone.Index] *
                                                AbsoluteTransform;
 
                        basicEffect.View = sceneGraph.Camera.View;
                        basicEffect.Projection = sceneGraph.Camera.Projection;
 
                        basicEffect.EnableDefaultLighting();
                    }
 
                    mesh.Draw(SaveStateMode.SaveState);
                }
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

public class Camera
{
    // Поля
    Vector3 position = Vector3.Zero;
    Quaternion rotation = Quaternion.Identity;
    float fieldOfView = (float)(System.Math.PI / 4.0);
    float aspectRatio = 4f / 3f;  // Ширина/Высота
    float nearPlane = 1.0f;
    float farPlane = 10500.0f;
    Matrix view;
    Matrix projection;
    BoundingFrustum frustum;
 
    // Свойства
    public Vector3 Position
    {
        get { return position; }
        set { position = value; }
    }
    public Quaternion Rotation
    {
        get { return rotation; }
        set { rotation = value; }
    }
    public float FieldOfView
    {
        get { return fieldOfView; }
        set { fieldOfView = value; }
    }
    public float AspectRatio
    {
        get { return aspectRatio; }
        set { aspectRatio = value; }
    }
    public float NearPlane
    {
        get { return nearPlane; }
        set { nearPlane = value; }
    }
    public float FarPlane
    {
        get { return farPlane; }
        set { farPlane = value; }
    }
    public Matrix View
    {
        get { return view; }
    }
    public Matrix Projection
    {
        get { return projection; }
    }
    public BoundingFrustum Frustum
    {
        get { return frustum; }
    }
 
    // Конструктор по умолчанию
    public Camera()
    {
    }
 
    // Методы
    public void LookAt(Vector3 target, Vector3 up)
    {
        view = Matrix.CreateLookAt(position, target, up);
 
        rotation = Quaternion.CreateFromRotationMatrix(Matrix.Invert(view));
    }
 
    public virtual void Update(SceneGraph sceneGraph)
    {
        projection = Matrix.CreatePerspectiveFieldOfView(fieldOfView,
                                                         aspectRatio,
                                                         nearPlane,
                                                         farPlane);
 
        Matrix matrix = Matrix.CreateFromQuaternion(rotation);
        matrix.Translation = position;
 
        view = Matrix.Invert(matrix);
 
        frustum = new BoundingFrustum(Matrix.Multiply(view, projection));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

public class SceneGraph
{
    // Поля
    SceneNode rootNode = new SceneNode();
    GraphicsDevice device;
    Camera camera;
    GameTime gameTime;
    int nodesCulled;
 
    // Свойства
    public SceneNode RootNode
    {
        get { return rootNode; }
        set { rootNode = value; }
    }
 
    public Camera Camera
    {
        get { return camera; }
        set { camera = value; }
    }
 
    public GameTime GameTime
    {
        get { return gameTime; }
    }
 
    public GraphicsDevice GraphicsDevice
    {
        get { return device; }
    }
 
    public int NodesCulled
    {
        get { return nodesCulled; }
    }
 
    // Конструктор
    public SceneGraph(GraphicsDevice device)
    {
        this.device = device;
    }
 
    // Методы
    void CalculateTransformsRecursive(SceneNode node)
    {
        node.AbsoluteTransform = Matrix.CreateTranslation(node.Offset) *
            Matrix.CreateFromQuaternion(node.Rotation) *
            node.AbsoluteTransform *
            Matrix.CreateTranslation(node.Position);
 
        //Рекурсивное обновление "потомков"
        foreach (SceneNode childNode in node.Children)
        {
            childNode.AbsoluteTransform = node.AbsoluteTransform;
            CalculateTransformsRecursive(childNode);
        }
    }
 
    void UpdateRecursive(SceneNode node)
    {
        //Обновление элемента
        node.Update(this);
 
        //Рекурсивное обновление "потомков"
        foreach (SceneNode childNode in node.Children)
        {
            UpdateRecursive(childNode);
        }
    }
 
    void DrawRecursive(SceneNode node)
    {
        //Отрисовка
        if (node.Visible)
        {
            BoundingSphere transformedSphere = new BoundingSphere();
            transformedSphere.Center = Vector3.Transform(node.BoundingSphere.Center,
                                                         node.AbsoluteTransform);
            transformedSphere.Radius = node.BoundingSphere.Radius;
            if (camera.Frustum.Intersects(transformedSphere))
            {
                node.Draw(this);
            }
            else
            {
                nodesCulled++;
            }
        }
 
        foreach (SceneNode childNode in node.Children)
        {
            DrawRecursive(childNode);
        }
    }
 
    void CalculateTransforms()
    {
        CalculateTransformsRecursive(rootNode);
    }
 
    public void Update(GameTime time)
    {
        gameTime = time;
 
        if (camera != null)
            camera.Update(this);
 
        UpdateRecursive(rootNode);
        CalculateTransformsRecursive(rootNode);
    }
 
    public void Draw()
    {
        nodesCulled = 0;
        rootNode.AbsoluteTransform = Matrix.Identity;
        DrawRecursive(rootNode);
    }
}

1
2
3
4

node.AbsoluteTransform = Matrix.CreateTranslation(node.Offset) *
            Matrix.CreateFromQuaternion(node.Rotation) *
            node.AbsoluteTransform *
            Matrix.CreateTranslation(node.Position);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

public class SceneGraphSampleGame : Microsoft.Xna.Framework.Game
{
    GraphicsDeviceManager graphics;
    ContentManager content;
    SceneGraph sceneGraph;
 
    // Конструктор
    public SceneGraphSampleGame()
    {
        graphics = new GraphicsDeviceManager(this);
        content = new ContentManager(Services);
    }
 
    // Методы
    protected override void Initialize()
    {
        base.Initialize();
    }
 
    protected override void LoadGraphicsContent(bool loadAllContent)
    {
        sceneGraph = new SceneGraph(graphics.GraphicsDevice);
 
        // Создание объекта для отображения модели
        ModelSceneNode modelNode = new ModelSceneNode(
                                        content.Load<Model>("Content/Ship"));
 
        // Присоединение объекта к графу сцены
        sceneGraph.RootNode.Children.Add(modelNode);
 
        // Создание камеры
        sceneGraph.Camera = new Camera();
        sceneGraph.Camera.Position = new Vector3(0, 0, 200);
    }
 
    protected override void Update(GameTime gameTime)
    {
        if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
            this.Exit();
 
        // Обновление графа сцены
        if (sceneGraph != null)
            sceneGraph.Update(gameTime);
 
		// Обновление прочих компонентов
        base.Update(gameTime);
    }
 
    protected override void Draw(GameTime gameTime)
    {
        graphics.GraphicsDevice.Clear(Color.CornflowerBlue);
 
        // Отрисовка графа сцены
        if (sceneGraph != null)
            sceneGraph.Draw();
 
        // Отрисовка прочих компонентов
        base.Draw(gameTime);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

public abstract class ControllerBase : IController
{
    public abstract void UpdateSceneNode(SceneNode node, GameTime gameTime);
}
 
public class XRotationController : ControllerBase
{
    // Поля
    float radiansPerSecond;
 
    // Свойства
    public float RadiansPerSecond
    {
        get { return radiansPerSecond; }
        set { radiansPerSecond = value; }
    }
 
    // Конструктор по умолчанию
    public XRotationController()
    {
    }
 
    // Методы
    public override void UpdateSceneNode(SceneNode node, GameTime gameTime)
    {
        if (radiansPerSecond != 0.0f)
        {
            float elapsedTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
            float rotation = radiansPerSecond * elapsedTime;
            node.Rotation *= Quaternion.CreateFromYawPitchRoll(0, rotation, 0);
        }
    }
}
 
public class YRotationController : ControllerBase
{
    // Поля
    float radiansPerSecond;
 
    // Публичные свойства
    public float RadiansPerSecond
    {
        get { return radiansPerSecond; }
        set { radiansPerSecond = value; }
    }
 
    // Конструктор по умолчанию
    public YRotationController()
    {
    }
 
    // Методы
    public override void UpdateSceneNode(SceneNode node, GameTime gameTime)
    {
        if (radiansPerSecond != 0.0f)
        {
            float elapsedTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
            float rotation = radiansPerSecond * elapsedTime;
            node.Rotation *= Quaternion.CreateFromYawPitchRoll(rotation, 0, 0);
        }
    }
}
 
public class ZRotationController : ControllerBase
{
    // Поля
    float radiansPerSecond;
 
    // Свойства
    public float RadiansPerSecond
    {
        get { return radiansPerSecond; }
        set { radiansPerSecond = value; }
    }
 
    // Конструктор по умолчанию
    public ZRotationController()
    {
    }
 
    // Методы
    public override void UpdateSceneNode(SceneNode node, GameTime gameTime)
    {
        if (radiansPerSecond != 0.0f)
        {
            float elapsedTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
            float rotation = radiansPerSecond * elapsedTime;
            node.Rotation *= Quaternion.CreateFromYawPitchRoll(0, 0, rotation);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

    protected override void LoadGraphicsContent(bool loadAllContent)
    {
        sceneGraph = new SceneGraph(graphics.GraphicsDevice);
 
        ModelSceneNode modelNode = new ModelSceneNode(content.Load<Model>("Content/Ship"));
        sceneGraph.RootNode.Children.Add(modelNode);
 
        sceneGraph.Camera = new Camera();
        sceneGraph.Camera.Position = new Vector3(0,0,200);
 
        // Код добавленный для использования контроллера
        YRotationController rotationController = new YRotationController();
        rotationController.RadiansPerSecond = (float)Math.PI;
 
        modelNode.Controller = rotationController;
    }