Configuring First-Person Camera in SlimDX and Assimp

Question

Configuring First-Person Camera in SlimDX and Assimp

Garrett Tiller 6

I'm developing a first-person shooter using SlimDX and Assimp, but I'm encountering some issues while trying to connect the camera and player classes. Below are the relevant code snippets:

private GameplayScreen(IntPtr hInstance)
    : base()
{ 
    //Enable4xMsaa = true;
    _camera = new FpsCamera
    {
        Position = Player.Position()
    };
}

private Player(IntPtr hInstance)
    : base()
{ 
    //Enable4xMsaa = true;
    _player = new SkinnedModel
    {
        Position = new Vector3(0, 2, -15)
    };
}

I'm facing the following errors:

Error CS7036: There is no argument given that corresponds to the required parameter 'device' of 'SkinnedModel.SkinnedModel(Device, TextureManager, string, string, bool)'
Error CS1955: Non-invocable member 'Player.Position' cannot be used like a method.

Any guidance on how to resolve these issues would be appreciated.

Anna Xiu-MSFT 31,056 Reputation points Microsoft External Staff

2024-10-29T02:29:23.9766667+00:00

Hello, what is your project type? If possible, please share us some reproduce steps to investigate it further.

Garrett Tiller 6

using Assimp;
using SlimDX.Direct3D10;
using SlimDX.DXGI;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Device = SlimDX.DXGI.Device;

namespace Redemption.Screen
{
    internal class GameplayScreen
    {

        private Camera _camera;
        private Device _device;
        private SwapChain _swapChain;
        private RenderTargetView _renderTargetView;
        private AssimpContext _assimpContext;
        public Player _player;
        public Level _level;

        private GameplayScreen(IntPtr hInstance)
    : base()
        {
            //Enable4xMsaa = true;
            _camera = new Camera
            {
                Position = Player.Position()
            }
            _device = device;
            _swapChain = swapChain;
            _assimpContext = new AssimpContext();

                Initialize();
        }

            private void Initialize()
            {
                using (var resource = SlimDX.Direct3D11.Resource.FromSwapChain<Texture2D>(_swapChain, 0))
                {
                    _renderTargetView = new RenderTargetView(_device, resource);
                }
            }


        public void Update(float deltaTime)
        {
            // Handle input and update camera position


            _level = new Level();
            

        }

        public void Render()
        {
            _device.ImmediateContext.OutputMerger.SetTargets(_renderTargetView);
            _device.ImmediateContext.ClearRenderTargetView(_renderTargetView, new Color(0.1f, 0.1f, 0.1f));

            var viewMatrix = _camera.GetViewMatrix();
            var projectionMatrix = _camera.GetProjectionMatrix(16.0f / 9.0f, (float)Math.PI / 4.0f, 0.1f, 100.0f);

            // Set shaders, input layout, and draw the model

            _player.Draw();

            _swapChain.Present(0, PresentFlags.None);
        }

    }
}

using Assimp;
using Core.Model;
using SlimDX;
using SlimDX.Direct3D11;
using SlimDX.DirectInput;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Device = SlimDX.Direct3D11.Device;
namespace Redemption
{
    public class Player
    {
        // Player properties
        public Vector3 Position { get; private set; }
        public Vector3 Rotation { get; private set; }
        public float Speed { get; set; }
        public float Sensitivity { get; set; }
        private SkinnedModel _model;
        private SkinnedModelInstance _modelInstance;
        private Mesh playerMesh;
        private SlimDX.Direct3D11.Device device;
        private ShaderResourceView textureView;
        // Input devices
        private Keyboard keyboard;
        private Mouse mouse;
        private Scene modelScene;
        private TextureManager _texMgr;
        public Player(Keyboard keyboard, Mouse mouse)
        {
            Position = new Vector3(0, 0, 0);
            Rotation = new Vector3(0, 0, 0);
            Speed = 0.1f;
            Sensitivity = 0.005f;
            this.keyboard = keyboard;
            this.mouse = mouse;
            
        }
        public override bool Initiate()
        {
            _model = new SkinnedModel(Device, _texMgr, "Models/drone.x", "Textures", true);
            _modelInstance = new SkinnedModelInstance(
                "Attack",
                Matrix.RotationY(MathF.PI) * Matrix.Translation(10, 0, 0),
                _model
                );
        }
        private void LoadModel(string path)
        {
            AssimpContext importer = new AssimpContext();
            modelScene = importer.ImportFile(path, PostProcessSteps.Triangulate | PostProcessSteps.GenerateNormals);
            if (modelScene == null)
            {
                throw new Exception("Failed to load model.");
            }
            // Process the model data (vertices, indices, etc.)
            foreach (var mesh in modelScene.Meshes)
            {
                // Example: Process vertices
                foreach (var vertex in mesh.Vertices)
                {
                    Vector3 position = new Vector3(vertex.X, vertex.Y, vertex.Z);
                    // Store or use the position as needed
                }
                // Example: Process indices
                foreach (var face in mesh.Faces)
                {
                    foreach (var index in face.Indices)
                    {
                        // Store or use the index as needed
                    }
                }
            }
        }
        private void ProcessNode(Node node, Scene scene)
        {
            foreach (int meshIndex in node.MeshIndices)
            {
                Mesh mesh = scene.Meshes[meshIndex];
                ProcessMesh(mesh, scene);
            }
            foreach (Node childNode in node.Children)
            {
                ProcessNode(childNode, scene);
            }
        }
        private void ProcessMesh(Mesh mesh, Scene scene)
        {
            // Convert Assimp mesh to SlimDX mesh
            // This is a simplified example, you may need to handle vertices, normals, texture coordinates, etc.
            // Create vertex buffer, index buffer, and other necessary resources here
            // Example: Create a simple vertex buffer
            DataStream vertexStream = new DataStream(mesh.VertexCount * Vector3.SizeInBytes, true, true);
            foreach (Vector3D vertex in mesh.Vertices)
            {
                vertexStream.Write(new Vector3(vertex.X, vertex.Y, vertex.Z));
            }
            vertexStream.Position = 0;
            BufferDescription bufferDesc = new BufferDescription
            {
                Usage = ResourceUsage.Default,
                SizeInBytes = (int)vertexStream.Length,
                BindFlags = BindFlags.VertexBuffer,
                CpuAccessFlags = CpuAccessFlags.None,
                OptionFlags = ResourceOptionFlags.None
            };
            SlimDX.Direct3D11.Buffer vertexBuffer = new SlimDX.Direct3D11.Buffer(device, vertexStream, bufferDesc);
            vertexStream.Dispose();
            // Store the vertex buffer in the playerMesh or another appropriate structure
            playerMesh = new Mesh { VertexBuffer = vertexBuffer };
        }
        public void Update()
        {
            // Update player position based on keyboard input
            var keyboardState = keyboard.GetCurrentState();
            if (keyboardState.IsPressed(Key.W))
                MoveForward();
            if (keyboardState.IsPressed(Key.S))
                MoveBackward();
            if (keyboardState.IsPressed(Key.A))
                StrafeLeft();
            if (keyboardState.IsPressed(Key.D))
                StrafeRight();
            // Update player rotation based on mouse input
            var mouseState = mouse.GetCurrentState();
            Rotate(mouseState.X, mouseState.Y);
        }
        public void Draw()
        {
            _model.Draw(playerMesh.VertexCount, 0);
        }
        private void MoveForward()
        {
            Position += Vector3.TransformCoordinate(new Vector3(0, 0, Speed), Matrix.RotationYawPitchRoll(Rotation.Y, Rotation.X, Rotation.Z));
        }
        private void MoveBackward()
        {
            Position -= Vector3.TransformCoordinate(new Vector3(0, 0, Speed), Matrix.RotationYawPitchRoll(Rotation.Y, Rotation.X, Rotation.Z));
        }
        private void StrafeLeft()
        {
            Position += Vector3.TransformCoordinate(new Vector3(Speed, 0, 0), Matrix.RotationYawPitchRoll(Rotation.Y, Rotation.X, Rotation.Z));
        }
        private void StrafeRight()
        {
            Position -= Vector3.TransformCoordinate(new Vector3(Speed, 0, 0), Matrix.RotationYawPitchRoll(Rotation.Y, Rotation.X, Rotation.Z));
        }
        private void Rotate(int deltaX, int deltaY)
        {
            Rotation = new Vector3(Rotation.X + deltaY * Sensitivity, Rotation.Y + deltaX * Sensitivity, Rotation.Z);
        }
    }
}

using System.Drawing;
using SlimDX;

namespace Core.Camera {
    public delegate float HeightFunc(float x, float y);
    public class FpsCamera : CameraBase {
        
        public override void LookAt(Vector3 pos, Vector3 target, Vector3 up) {
            Position = pos;
            Look = Vector3.Normalize(target - pos);
            Right = Vector3.Normalize(Vector3.Cross(up, Look));
            Up = Vector3.Cross(Look, Right);
        }

        public override void Strafe(float d) {
            Position += Right * d;
        }

        public override void Walk(float d) {
            Position += Look * d;
        }

        public override void Pitch(float angle) {
            var r = Matrix.RotationAxis(Right, angle);
            Up = Vector3.TransformNormal(Up, r);
            Look = Vector3.TransformNormal(Look, r);
        }

        public override void Yaw(float angle) {
            var r = Matrix.RotationY(angle);
            Right = Vector3.TransformNormal(Right, r);
            Up = Vector3.TransformNormal(Up, r);
            Look = Vector3.TransformNormal(Look, r);
        }
        public override void Zoom(float dr) {
            var newFov = MathF.Clamp(FovY + dr, 0.1f, MathF.PI / 2);
            SetLens(newFov, Aspect, NearZ, FarZ);
        }

        public override void UpdateViewMatrix() {
            var r = Right;
            var u = Up;
            var l = Look;
            var p = Position;

            l = Vector3.Normalize(l);
            u = Vector3.Normalize(Vector3.Cross(l, r));

            r = Vector3.Cross(u, l);

            var x = -Vector3.Dot(p, r);
            var y = -Vector3.Dot(p, u);
            var z = -Vector3.Dot(p, l);

            Right = r;
            Up = u;
            Look = l;

            var v = new Matrix();
            v[0, 0] = Right.X;
            v[1, 0] = Right.Y;
            v[2, 0] = Right.Z;
            v[3, 0] = x;

            v[0, 1] = Up.X;
            v[1, 1] = Up.Y;
            v[2, 1] = Up.Z;
            v[3, 1] = y;

            v[0, 2] = Look.X;
            v[1, 2] = Look.Y;
            v[2, 2] = Look.Z;
            v[3, 2] = z;

            v[0, 3] = v[1, 3] = v[2, 3] = 0;
            v[3, 3] = 1;

            View = v;

            _frustum = Frustum.FromViewProj(ViewProj);
        }
    }
}

Your answer

Anna Xiu-MSFT 31,056 Reputation points Microsoft External Staff

2024-10-29T02:29:23.9766667+00:00

Hello, what is your project type? If possible, please share us some reproduce steps to investigate it further.

Share via

Configuring First-Person Camera in SlimDX and Assimp

Your answer