Ejemplo n.º 1
0
        private void BuildNode(Node parent, ref Matrix4x4 rootTransform)
        {
            Matrix4x4 world   = rootTransform;
            Matrix4   worldTK = Matrix4.Identity;

            if (UseTransformMatrix)
            {
                Matrix4x4 trafo = parent.Transform;
                world   = trafo * rootTransform;
                worldTK = AssimpHelper.TKMatrix(world);
            }

            if (parent.MeshCount > 0)
            {
                STConsole.WriteLine($"Use Transform Matrix {UseTransformMatrix}");
                STConsole.WriteLine($"Transform node {parent.Name}");
                STConsole.WriteLine($"Translation {worldTK.ExtractTranslation()}");
                STConsole.WriteLine($"Rotation {worldTK.ExtractRotation()}");
                STConsole.WriteLine($"Scale {worldTK.ExtractScale()}");
            }

            foreach (int index in parent.MeshIndices)
            {
                objects.Add(CreateGenericObject(parent, scene.Meshes[index], index, worldTK));
            }

            foreach (Node child in parent.Children)
            {
                BuildNode(child, ref world);
            }
        }
Ejemplo n.º 2
0
        public void SetFileSizeEntry(string FileName, uint Size)
        {
            uint OldSize = FileSizes[FileName];

            FileSizes[FileName] = Size;

            STConsole.WriteLine($"Old size: {OldSize} New size: {Size}");
        }
Ejemplo n.º 3
0
        public void SetEntry(string FileName, byte[] Data = null, bool IsYaz0Compressed = false, bool Force = false)
        {
            uint OldSize = GetSize(FileName);
            uint NewSize = (uint)ParseSize(FileName, Data, IsYaz0Compressed, Force) + 8192; //Add an additional set of bytes for some room

            STConsole.WriteLine($"Setting {FileName} OldSize {OldSize} NewSize {NewSize} Is Yaz0 Compressed {IsYaz0Compressed}");

            SetSize(FileName, NewSize);
        }
Ejemplo n.º 4
0
        public void LoadScene()
        {
            objects.Clear();
            materials.Clear();
            BoneNames.Clear();
            skeleton = new STSkeleton();

            processNode();

            if (scene.RootNode != null)
            {
                var     rootTransform = scene.RootNode.Transform;
                Matrix4 transformMat  = AssimpHelper.TKMatrix(rootTransform);

                var scale    = transformMat.ExtractScale();
                var rotation = transformMat.ExtractRotation();
                var position = transformMat.ExtractTranslation();

                STConsole.WriteLine($"-".Repeat(30));
                STConsole.WriteLine($"rootTransform {transformMat}");
                STConsole.WriteLine($"scale {scale}");
                STConsole.WriteLine($"rotation {rotation}");
                STConsole.WriteLine($"position {position}");
                STConsole.WriteLine($"-".Repeat(30));

                var SklRoot = GetSklRoot(scene.RootNode, BoneNames);
                if (SklRoot != null)
                {
                    BuildSkeletonNodes(SklRoot, BoneNames, skeleton, ref rootTransform);
                }
                else
                {
                    BuildSkeletonNodes(scene.RootNode, BoneNames, skeleton, ref rootTransform);
                }

                skeleton.update();
                skeleton.reset();
            }


            if (scene.HasMaterials)
            {
                foreach (Material mat in scene.Materials)
                {
                    materials.Add(CreateGenericMaterial(mat));
                }
            }
            foreach (Assimp.Animation animation in scene.Animations)
            {
            }
            foreach (var tex in scene.Textures)
            {
            }
        }
Ejemplo n.º 5
0
        public bool LoadFile(string FileName)
        {
            try
            {
                var settings = new Assimp_Settings();
                if (settings.ShowDialog() == DialogResult.OK)
                {
                    UseTransformMatrix   = settings.UseNodeTransform;
                    RotateSkeleton       = settings.RotateSkeleton;
                    RotateSkeletonAmount = settings.RotateSkeletonAmount;

                    AssimpContext Importer = new AssimpContext();

                    STConsole.WriteLine($"Loading File {FileName}", Color.FromArgb(0, 255, 0));

                    /*  var Flags = PostProcessSteps.Triangulate;
                     * Flags |= PostProcessSteps.JoinIdenticalVertices;
                     * Flags |= PostProcessSteps.FlipUVs;
                     * Flags |= PostProcessSteps.LimitBoneWeights;
                     * Flags |= PostProcessSteps.CalculateTangentSpace;
                     * Flags |= PostProcessSteps.GenerateNormals;*/



                    scene = Importer.ImportFile(FileName, settings.GetFlags());

                    if (Utils.GetExtension(FileName) == ".dae")
                    {
                        GetRealNodeNames(FileName);
                    }

                    STConsole.WriteLine($"UnitScale {UnitScale}");

                    LoadScene();

                    return(true);
                }
                return(false);
            }
            catch (Exception e)
            {
                if (e.ToString().Contains("Error loading unmanaged library from path"))
                {
                    MessageBox.Show($"Failed to load assimp! Make sure you have Assimp32.dll next to the program!");
                }
                else
                {
                    MessageBox.Show($"{e.ToString()}");
                }

                return(false);
            }
        }
Ejemplo n.º 6
0
        private STGenericMatTexture CreateTextureSlot(TextureSlot tex, TextureType type)
        {
            var matTex = new STGenericMatTexture();

            switch (type)
            {
            case TextureType.Diffuse:
                matTex.Type = STGenericMatTexture.TextureType.Diffuse;
                break;

            case TextureType.Normals:
                matTex.Type = STGenericMatTexture.TextureType.Normal;
                break;

            case TextureType.Lightmap:
                matTex.Type = STGenericMatTexture.TextureType.Light;
                break;

            case TextureType.Emissive:
                matTex.Type = STGenericMatTexture.TextureType.Emission;
                break;

            case TextureType.Specular:
                matTex.Type = STGenericMatTexture.TextureType.Specular;
                break;

            case TextureType.Shininess:
                matTex.Type = STGenericMatTexture.TextureType.Metalness;
                break;

            case TextureType.Opacity:
                matTex.Type = STGenericMatTexture.TextureType.Transparency;
                break;

            case TextureType.Displacement:
                break;

            default:
                matTex.Type = STGenericMatTexture.TextureType.Unknown;
                break;
            }

            matTex.Name      = System.IO.Path.GetFileNameWithoutExtension(tex.FilePath);
            matTex.WrapModeS = SetWrapMode(tex.WrapModeU);
            matTex.WrapModeT = SetWrapMode(tex.WrapModeV);

            STConsole.WriteLine($"Getting assimp texture slot {matTex.Name} Type {matTex.Type}");

            return(matTex);
        }
Ejemplo n.º 7
0
        public static Animations.Animation[] ImportAnimations(string FileName)
        {
            AssimpContext Importer = new AssimpContext();

            STConsole.WriteLine($"Loading File {FileName}", Color.FromArgb(0, 255, 0));

            var scene = Importer.ImportFile(FileName);

            List <Animations.Animation> Anims = new List <Animations.Animation>();

            foreach (var anim in scene.Animations)
            {
                Anims.Add(CreateGenericAnimation(anim));
            }

            return(Anims.ToArray());
        }
Ejemplo n.º 8
0
        public void processNode()
        {
            Console.WriteLine($"Mesh Count " + scene.MeshCount);
            Matrix4x4 identity = Matrix4x4.Identity;

            if (scene.RootNode != null)
            {
                BuildNode(scene.RootNode, ref identity);
                Console.WriteLine($"BuildNode Mesh Count " + scene.MeshCount);
            }
            else
            {
                STConsole.WriteLine("No root node found! Will default to Idenity Matrix!", Color.Red);

                int Index = 0;
                foreach (Mesh msh in scene.Meshes)
                {
                    objects.Add(CreateGenericObject(null, msh, Index, Matrix4.Identity));
                    Index++;
                }
            }
        }
Ejemplo n.º 9
0
        private void CreateByNode(Node node, STSkeleton skeleton, string ParentArmatureName,
                                  short SmoothIndex, short RigidIndex, bool IsRoot, ref Assimp.Matrix4x4 rootTransform)
        {
            Matrix4x4 trafo        = node.Transform;
            Matrix4x4 world        = trafo * rootTransform;
            var       transformMat = AssimpHelper.TKMatrix(world);

            int matchedBoneIndex = skeleton.bones.FindIndex(item => item.Name == node.Name);

            if (matchedBoneIndex < 0)
            {
                tempBoneNodes.Add(node);

                STBone bone = new STBone();
                bone.skeletonParent = skeleton;
                bone.RotationType   = STBone.BoneRotationType.Euler;
                skeleton.bones.Add(bone);

                if (DaeHelper.IDMapToName.ContainsKey(node.Name))
                {
                    bone.Text = DaeHelper.IDMapToName[node.Name];
                }
                else
                {
                    bone.Text = node.Name;
                }

                bone.SmoothMatrixIndex = (short)skeleton.bones.IndexOf(bone);
                bone.RigidMatrixIndex  = -1; //Todo calculate these

                if (IsRoot)
                {
                    bone.parentIndex = -1;

                    if (RotateSkeleton)
                    {
                        transformMat = AssimpHelper.TKMatrix(world * Matrix4x4.FromRotationX(MathHelper.DegreesToRadians(RotateSkeletonAmount)));
                    }
                    else
                    {
                        transformMat = AssimpHelper.TKMatrix(world);
                    }
                }
                else
                {
                    if (tempBoneNodes.Contains(node.Parent))
                    {
                        bone.parentIndex = tempBoneNodes.IndexOf(node.Parent);
                    }
                }


                var scale    = transformMat.ExtractScale();
                var rotation = transformMat.ExtractRotation();
                var position = transformMat.ExtractTranslation();

                STConsole.WriteLine($"-".Repeat(30));
                STConsole.WriteLine($"Processing Bone {bone.Text}");
                STConsole.WriteLine($"scale {scale}");
                STConsole.WriteLine($"rotation {rotation}");
                STConsole.WriteLine($"position {position}");
                STConsole.WriteLine($"-".Repeat(30));

                bone.FromTransform(transformMat);
            }
            else
            {
                STConsole.WriteLine($"Duplicate node name found for bone {node.Name}!", Color.Red);
            }

            var identity = Matrix4x4.Identity;

            foreach (Node child in node.Children)
            {
                CreateByNode(child, skeleton, ParentArmatureName, SmoothIndex, RigidIndex, false, ref identity);
            }
        }
Ejemplo n.º 10
0
        public static Animations.Animation CreateGenericAnimation(Assimp.Animation animation)
        {
            Animations.Animation STanim = new Animations.Animation();
            STanim.Text = animation.Name;
            float TicksPerSecond = animation.TicksPerSecond != 0 ? (float)animation.TicksPerSecond : 25.0f;
            float Duriation      = (float)animation.DurationInTicks;

            STanim.FrameCount = (int)(Duriation * 30);


            //Load node animations
            if (animation.HasNodeAnimations)
            {
                var _channels = new NodeAnimationChannel[animation.NodeAnimationChannelCount];
                for (int i = 0; i < _channels.Length; i++)
                {
                    _channels[i] = new NodeAnimationChannel();
                    var boneAnim = new Animations.Animation.KeyNode(_channels[i].NodeName);
                    boneAnim.RotType = Animations.Animation.RotationType.EULER;
                    STanim.Bones.Add(boneAnim);

                    STConsole.WriteLine($"Creating Bone Anims {boneAnim.Text} ");

                    for (int frame = 0; frame < STanim.FrameCount; i++)
                    {
                        if (_channels[i].HasPositionKeys)
                        {
                            for (int key = 0; key < _channels[i].PositionKeyCount; key++)
                            {
                                if (frame == _channels[i].PositionKeys[key].Time)
                                {
                                    boneAnim.XPOS.Keys.Add(new Animations.Animation.KeyFrame()
                                    {
                                        Value = _channels[i].PositionKeys[key].Value.X,
                                        Frame = frame,
                                    });
                                    boneAnim.YPOS.Keys.Add(new Animations.Animation.KeyFrame()
                                    {
                                        Value = _channels[i].PositionKeys[key].Value.Y,
                                        Frame = frame,
                                    });
                                    boneAnim.ZPOS.Keys.Add(new Animations.Animation.KeyFrame()
                                    {
                                        Value = _channels[i].PositionKeys[key].Value.Z,
                                        Frame = frame,
                                    });
                                }
                            }
                        }
                        if (_channels[i].HasRotationKeys)
                        {
                            for (int key = 0; key < _channels[i].RotationKeyCount; key++)
                            {
                                if (frame == _channels[i].RotationKeys[key].Time)
                                {
                                    var quat  = _channels[i].RotationKeys[key].Value;
                                    var euler = STMath.ToEulerAngles(quat.X, quat.Y, quat.Z, quat.W);

                                    boneAnim.XROT.Keys.Add(new Animations.Animation.KeyFrame()
                                    {
                                        Value = euler.X,
                                        Frame = frame,
                                    });
                                    boneAnim.YROT.Keys.Add(new Animations.Animation.KeyFrame()
                                    {
                                        Value = euler.Y,
                                        Frame = frame,
                                    });
                                    boneAnim.ZROT.Keys.Add(new Animations.Animation.KeyFrame()
                                    {
                                        Value = euler.Z,
                                        Frame = frame,
                                    });
                                    boneAnim.WROT.Keys.Add(new Animations.Animation.KeyFrame()
                                    {
                                        Value = 1,
                                        Frame = frame,
                                    });
                                }
                            }
                        }
                        if (_channels[i].HasScalingKeys)
                        {
                            for (int key = 0; key < _channels[i].ScalingKeyCount; key++)
                            {
                                if (frame == _channels[i].ScalingKeys[key].Time)
                                {
                                    boneAnim.XSCA.Keys.Add(new Animations.Animation.KeyFrame()
                                    {
                                        Value = _channels[i].ScalingKeys[key].Value.X,
                                        Frame = frame,
                                    });
                                    boneAnim.YSCA.Keys.Add(new Animations.Animation.KeyFrame()
                                    {
                                        Value = _channels[i].ScalingKeys[key].Value.Y,
                                        Frame = frame,
                                    });
                                    boneAnim.ZSCA.Keys.Add(new Animations.Animation.KeyFrame()
                                    {
                                        Value = _channels[i].ScalingKeys[key].Value.Z,
                                        Frame = frame,
                                    });
                                }
                            }
                        }
                    }
                }
            }

            //Load mesh animations
            if (animation.HasMeshAnimations)
            {
                var _meshChannels = new MeshAnimationChannel[animation.MeshAnimationChannelCount];
                for (int i = 0; i < _meshChannels.Length; i++)
                {
                    _meshChannels[i] = new MeshAnimationChannel();
                }
            }

            return(STanim);
        }