binaries/assimp-3.1.1/port/Assimp.NET/Assimp.NET_DEMO/AssimpView.cs

/*
---------------------------------------------------------------------------
Open Asset Import Library (ASSIMP)
---------------------------------------------------------------------------

Copyright (c) 2006-2010, ASSIMP Development Team

All rights reserved.

Redistribution and use of this software in source and binary forms, 
with or without modification, are permitted provided that the following 
conditions are met:

* Redistributions of source code must retain the above
  copyright notice, this list of conditions and the
  following disclaimer.

* Redistributions in binary form must reproduce the above
  copyright notice, this list of conditions and the
  following disclaimer in the documentation and/or other
  materials provided with the distribution.

* Neither the name of the ASSIMP team, nor the names of its
  contributors may be used to endorse or promote products
  derived from this software without specific prior
  written permission of the ASSIMP Development Team.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Text;
using System.Windows.Forms;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

namespace Assimp.Viewer
{
    public partial class AssimpView : Form
    {
        public AssimpView()
        {
            InitializeComponent();

            // Window title
            this.Text = "Assimp .NET Viewer";

            // Ignore WM_ERASEBKGND messages to prevent flicker
            this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);

            // Listen to mouse
            this.MouseDown += new MouseEventHandler(AssimpView_MouseDown);
            this.MouseMove += new MouseEventHandler(AssimpView_MouseMove);
            this.MouseUp += new MouseEventHandler(AssimpView_MouseUp);
            this.MouseWheel += new MouseEventHandler(AssimpView_MouseWheel);
        }

        void AssimpView_MouseWheel(object sender, MouseEventArgs e) {
			g_sCamera.vPos.Z *= 1.0f - (e.Delta / 1000.0f);
            Refresh();
        }

        private void AssimpView_MouseDown(object sender, MouseEventArgs e) {
            UpdateMouseState(e);
        }

        private void AssimpView_MouseMove(object sender, MouseEventArgs e) {
            UpdateMouseState(e);
        }

        private void AssimpView_MouseUp(object sender, MouseEventArgs e) {
            UpdateMouseState(e);
        }

        private void UpdateMouseState(MouseEventArgs e) {
            g_bMousePressed = (e.Button == MouseButtons.Left);
            g_bMousePressedR = (e.Button == MouseButtons.Right);
            g_bMousePressedM = (e.Button == MouseButtons.Middle);
            g_bMousePressedBoth = (e.Button == (MouseButtons.Left | MouseButtons.Right));
            Refresh();
        }

        protected override void OnPaintBackground(PaintEventArgs pevent) {
            /* Do nothing to prevent flicker during resize */
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            InitializeDevice();
            InitializeAssimp();
        }

        private void Form1_SizeChanged(object sender, EventArgs e) {
            presentParams.BackBufferWidth = Width;
            presentParams.BackBufferHeight = Height;
            device.Reset(presentParams);
            Invalidate();
        }

        public void InitializeDevice()
        {
            // Improve Performance
            // http://blogs.msdn.com/b/tmiller/archive/2003/11/14/57531.aspx
            Device.IsUsingEventHandlers = false;

            // For Windowed mode leave Width and Height at 0
            var adapter = Manager.Adapters.Default;
            presentParams = new PresentParameters();
            presentParams.AutoDepthStencilFormat = DepthFormat.D16;
            presentParams.EnableAutoDepthStencil = true;
            presentParams.Windowed = true;
            presentParams.SwapEffect = SwapEffect.Discard;

            // Keep precision in floating point calculations
            // http://blogs.msdn.com/b/tmiller/archive/2004/06/01/145596.aspx
            var createFlags = CreateFlags.FpuPreserve;

            // Pure device for performance - all device render states are now write only
            var deviceType = DeviceType.Hardware;
            var caps = Manager.GetDeviceCaps(adapter.Adapter, deviceType);
            if (caps.DeviceCaps.SupportsPureDevice) {
                createFlags |= CreateFlags.PureDevice;
            }

            // Warning: some drivers lie about supporting HT&L. Use Software if you see problems.
            if (caps.DeviceCaps.SupportsHardwareTransformAndLight) {
                createFlags |= CreateFlags.HardwareVertexProcessing;
            }
            else {
                createFlags |= CreateFlags.SoftwareVertexProcessing;
            }

            // Create Device
            device = new Device(adapter.Adapter, deviceType, this, createFlags, presentParams);

            // Add event handlers
            device.DeviceResizing += new CancelEventHandler(device_DeviceResizing);
        }

        private void device_DeviceResizing(object sender, CancelEventArgs e) {
            device.Reset();
        }

        // default pp steps
        private static aiPostProcessSteps ppsteps =
            aiPostProcessSteps.aiProcess_CalcTangentSpace | // calculate tangents and bitangents if possible
            aiPostProcessSteps.aiProcess_JoinIdenticalVertices | // join identical vertices/ optimize indexing
            aiPostProcessSteps.aiProcess_ValidateDataStructure | // perform a full validation of the loader's output
            aiPostProcessSteps.aiProcess_ImproveCacheLocality | // improve the cache locality of the output vertices
            aiPostProcessSteps.aiProcess_RemoveRedundantMaterials | // remove redundant materials
            aiPostProcessSteps.aiProcess_FindDegenerates | // remove degenerated polygons from the import
            aiPostProcessSteps.aiProcess_FindInvalidData | // detect invalid model data, such as invalid normal vectors
            aiPostProcessSteps.aiProcess_GenUVCoords | // convert spherical, cylindrical, box and planar mapping to proper UVs
            aiPostProcessSteps.aiProcess_TransformUVCoords | // preprocess UV transformations (scaling, translation ...)
            aiPostProcessSteps.aiProcess_FindInstances | // search for instanced meshes and remove them by references to one master
            aiPostProcessSteps.aiProcess_LimitBoneWeights | // limit bone weights to 4 per vertex
            aiPostProcessSteps.aiProcess_OptimizeMeshes | // join small meshes, if possible;
		    (aiPostProcessSteps)0;


        public void InitializeAssimp() {
            var flags = ( ppsteps |
                aiPostProcessSteps.aiProcess_GenSmoothNormals | // generate smooth normal vectors if not existing
                aiPostProcessSteps.aiProcess_SplitLargeMeshes | // split large, unrenderable meshes into submeshes
                aiPostProcessSteps.aiProcess_Triangulate | // triangulate polygons with more than 3 edges
                aiPostProcessSteps.aiProcess_ConvertToLeftHanded | // convert everything to D3D left handed space
                aiPostProcessSteps.aiProcess_SortByPType | // make 'clean' meshes which consist of a single typ of primitives
                (aiPostProcessSteps)0);

            // default model
            var path = "../../../../../test/models/3DS/test1.3ds";

            importer = new Importer();
            string[] args = Environment.GetCommandLineArgs();
            if (args.Length > 1) {
                path = args[1];
            }

            
            //var path = "man.3ds";
            scene = importer.ReadFile(path, flags);
            if (scene != null)
            {
                directory = Path.GetDirectoryName(path);
                CacheMaterials(scene.mMaterials);
                CacheMeshes(scene.mMeshes);
                SetupCamera(scene.mCameras);
            }
            else {
                MessageBox.Show("Failed to open file: " + path + ". Either Assimp screwed up or the path is not valid.");
                Application.Exit();
            }
        }

        private void CacheMeshes(aiMeshVector meshes) {
            var numMeshes = meshes.Count;
            meshCache = new Mesh[numMeshes];
            meshBoundsMin = new Vector3[numMeshes];
            meshBoundsMax = new Vector3[numMeshes];

            for (int i = 0; i < numMeshes; ++i) {
                var mesh = meshes[i];

                switch (mesh.mPrimitiveTypes) {
                case aiPrimitiveType.aiPrimitiveType_TRIANGLE:
                    Vector3 min, max;
                    meshCache[i] = CreateMesh(mesh, out min, out max);
                    meshBoundsMin[i] = min;
                    meshBoundsMax[i] = max;
                    break;
                }
            }
        }

        private void CacheMaterials(aiMaterialVector materials) {
            var numMaterials = materials.Count;
            materialCache = new ExtendedMaterial[numMaterials];
            textureCache = new Dictionary<string, Texture>();

            for (int i = 0; i < numMaterials; ++i) {
                var material = materials[i];
                var dxExtendedMaterial = new ExtendedMaterial();
                var dxMaterial = new Material();
                dxMaterial.AmbientColor = material.Ambient.ToColorValue();
                dxMaterial.DiffuseColor = material.Diffuse.ToColorValue();
                dxMaterial.EmissiveColor = material.Emissive.ToColorValue();
                dxMaterial.SpecularColor = material.Specular.ToColorValue();
                dxMaterial.SpecularSharpness = material.ShininessStrength;
                dxExtendedMaterial.Material3D = dxMaterial;
                dxExtendedMaterial.TextureFilename = material.TextureDiffuse0;

                materialCache[i] = dxExtendedMaterial;

                var textureFilename = dxExtendedMaterial.TextureFilename;
                if (!string.IsNullOrEmpty(textureFilename) && !textureCache.ContainsKey(textureFilename)) {
                    textureCache.Add(textureFilename, CreateTexture(textureFilename));
                }
            }
        }

        private Texture CreateTexture(string fileName) {
            var path = Path.Combine(directory, fileName);
            try {
                using (var data = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read)) {
                    var dxTexture = Texture.FromStream(device, data, Usage.None, Pool.Managed);
                    textureCache[path] = dxTexture;
                    return dxTexture;
                }
            }
            catch (Exception) {
                return null;
            }
        }

        private Mesh CreateMesh(aiMesh aiMesh, out Vector3 min, out Vector3 max) {
            var numFaces = (int) aiMesh.mNumFaces;
            var numVertices = (int) aiMesh.mNumVertices;

            var dxMesh = new Mesh(numFaces, numVertices, MeshFlags.Managed | MeshFlags.Use32Bit,
                CustomVertex.PositionNormalTextured.Format, device);

            var aiPositions = aiMesh.mVertices;
            var aiNormals = aiMesh.mNormals;
            var aiTextureCoordsAll = aiMesh.mTextureCoords;
            var aiTextureCoords = (aiTextureCoordsAll!=null) ? aiTextureCoordsAll[0] : null;
            var dxVertices = new CustomVertex.PositionNormalTextured[numVertices];
            for (int i = 0; i < numVertices; ++i) {
                dxVertices[i].Position = aiPositions[i].ToVector3();
                if (aiNormals != null) {
                    dxVertices[i].Normal = aiNormals[i].ToVector3();
                }
                if (aiTextureCoords != null) {
                    var uv = aiTextureCoords[i];
                    dxVertices[i].Tu = uv.x;
                    dxVertices[i].Tv = uv.y;
                }
            }
            dxMesh.VertexBuffer.SetData(dxVertices, 0, LockFlags.None);

            var aiFaces = aiMesh.mFaces;
            var dxIndices = new uint[numFaces * 3];
            for (int i = 0; i < numFaces; ++i) {
                var aiFace = aiFaces[i];
                var aiIndices = aiFace.mIndices;
                for (int j = 0; j < 3; ++j) {
                    dxIndices[i * 3 + j] = aiIndices[j];
                }
            }
            dxMesh.IndexBuffer.SetData(dxIndices, 0, LockFlags.None);

            var dxAttributes = dxMesh.LockAttributeBufferArray(LockFlags.None);
            // TODO: Set face material index for attributes
            dxMesh.UnlockAttributeBuffer(dxAttributes);

            var adjacency = new int[numFaces * 3];
            dxMesh.GenerateAdjacency(0.0f, adjacency);
            dxMesh.OptimizeInPlace(MeshFlags.OptimizeAttributeSort, adjacency);

            Geometry.ComputeBoundingBox(dxVertices, CustomVertex.PositionNormalTextured.StrideSize, out min, out max);

            return dxMesh;
        }

        //-------------------------------------------------------------------------------
        // Calculate the boundaries of a given node and all of its children
        // The boundaries are in Worldspace (AABB)
        // piNode Input node
        // min/max Receives the min/max boundaries
        // piMatrix Transformation matrix of the graph at this position
        //-------------------------------------------------------------------------------
        private void CalculateBounds(aiNode piNode, ref Vector3 min, ref Vector3 max, Matrix piMatrix) {
            Debug.Assert(null != piNode);

            var mTemp = piNode.mTransformation.ToMatrix();
            var aiMe = mTemp * piMatrix;

            var meshes = piNode.mMeshes;
            var numMeshes = meshes.Count;
            for (int i = 0; i < numMeshes; ++i) {
                var mesh = meshes[i];
                var meshMin = Vector3.TransformCoordinate(meshBoundsMin[mesh], aiMe);
                var meshMax = Vector3.TransformCoordinate(meshBoundsMax[mesh], aiMe);
                min.X = Math.Min(min.X, meshMin.X);
                min.Y = Math.Min(min.Y, meshMin.Y);
                min.Z = Math.Min(min.Z, meshMin.Z);
                max.X = Math.Max(max.X, meshMax.X);
                max.Y = Math.Max(max.Y, meshMax.Y);
                max.Z = Math.Max(max.Z, meshMax.Z);
            }
            var children = piNode.mChildren;
            var numChildren = children.Count;
            for (int i = 0; i < numChildren; ++i) {
                CalculateBounds(children[i], ref min, ref max, aiMe);
            }
        }

        protected override void OnPaint(System.Windows.Forms.PaintEventArgs e) {
            HandleMouseInputLocal();
            Render();
        }

        private void Render() {
            device.Clear(ClearFlags.Target|ClearFlags.ZBuffer, Color.DarkSlateBlue, 1.0f, 0);
            device.BeginScene();

            SetupMatrices();

            if (scene != null && scene.mRootNode != null) {
                SetupLights(scene.mLights);
                RenderNode(scene.mRootNode, g_mWorldRotate);
            }

            device.EndScene();
            device.Present();
        }

        private void SetupMatrices() {
            var fovy = Geometry.DegreeToRadian(45.0f);
            var aspect = ((float)this.Width / (float)this.Height);
            device.Transform.Projection = Matrix.PerspectiveFovLH(fovy, aspect, g_zNear, g_zFar);
            device.Transform.View = g_sCamera.GetMatrix();
        }

        private void SetupCamera(aiCameraVector cameras) {
            // Get scene bounds
            var min = new Vector3(float.MaxValue, float.MaxValue, float.MaxValue);
            var max = new Vector3(float.MinValue, float.MinValue, float.MinValue);
            CalculateBounds(scene.mRootNode, ref min, ref max, Matrix.Identity);

            // Projection Depth
            var size = (max-min);
            g_zFar = Math.Max(Math.Max(size.X, size.Y), size.Z) * 100;

            // Starting View Position
            var center = min + size * 0.5f;
            var lookAt = new Vector3(0,0,1); // Unit vector not coordinate
            var position = new Vector3(center.X, center.Y, center.Z-(size.Z*10));
            var up = new Vector3(0, 1, 0);
            if (cameras.Count > 0) {
                var camera = cameras[0];
                lookAt = camera.mLookAt.ToVector3();
                position = camera.mPosition.ToVector3();
                up = camera.mUp.ToVector3();
            }
            g_sCamera.vLookAt = lookAt;
            g_sCamera.vPos = position;
            g_sCamera.vUp = up;
        }

        private void SetupLights(aiLightVector lights) {
            var numLights = lights.Count;

            if (numLights == 0) {
                var light = device.Lights[0];
                light.Type = LightType.Directional;
                light.Diffuse = Color.LightGray;
                light.Direction = new Vector3(-1, -1, 1);
                light.Enabled = true;
            }
            else {
                // TODO: setup lights
            }

            // Enables lighting
            device.RenderState.Lighting = true;
            device.RenderState.Ambient = Color.DarkGray;
            device.RenderState.SpecularEnable = true;
        }

        private void RenderNode(aiNode node, Matrix parentMatrix) {
            var nodeMatrix = node.mTransformation.ToMatrix() * parentMatrix;

            var children = node.mChildren;
            var numChildren = node.mNumChildren;
            for (int i = 0; i < numChildren; ++i) {
                var child = children[i];
                RenderNode(child, nodeMatrix);
            }

            device.Transform.World = nodeMatrix;
            var meshes = node.mMeshes;
            var numMeshes = meshes.Count;
            for (int i = 0; i < numMeshes; ++i) {
                var meshId = (int)meshes[i];
                var mesh = scene.mMeshes[meshId];
                var materialId = (int)mesh.mMaterialIndex;

                var dxMaterial = materialCache[materialId];
                device.Material = dxMaterial.Material3D;

                Texture dxTexture = null;
                if (!string.IsNullOrEmpty(dxMaterial.TextureFilename)) {
                    textureCache.TryGetValue(dxMaterial.TextureFilename, out dxTexture);
                }
                device.SetTexture(0, dxTexture);

                var dxMesh = meshCache[meshId];
                RenderMesh(dxMesh);
            }
        }

        private void RenderMesh(Mesh mesh) {
            for (int i = 0; i < mesh.NumberAttributes; ++i) {
                mesh.DrawSubset(i);
            }
        }

        private Device device;
        private PresentParameters presentParams;

        private Importer importer;
        private string directory;
        private aiScene scene;
        private Mesh[] meshCache;
        private ExtendedMaterial[] materialCache;
        private Dictionary<string, Texture> textureCache;
        private Vector3[] meshBoundsMin;
        private Vector3[] meshBoundsMax;

        private Camera g_sCamera = new Camera();
        private float g_zNear = 0.2f;
        private float g_zFar = 1000.0f;
        private Matrix g_mProjection = Matrix.Identity;
        private Matrix g_mWorldRotate = Matrix.Identity;
    }

    //-------------------------------------------------------------------------------
    // Position of the cursor relative to the 3ds max' like control circle
    //-------------------------------------------------------------------------------
    public enum EClickPos {
        // The click was inside the inner circle (x,y axis)
        Circle,
        // The click was inside one of tghe vertical snap-ins
        CircleVert,
        // The click was inside onf of the horizontal snap-ins
        CircleHor,
        // the cklick was outside the circle (z-axis)
        Outside
    };
}