Ejemplo n.º 1
0
        /// <summary>
        /// Generates the geometry needed for this object
        /// </summary>
        internal static Geometry GenerateGeometry(ACFileInfo fileInfo)
        {
            var result = new Geometry();

            // Create a surface for each material first
            var materialList = fileInfo.Materials;

            for (var actMaterialIndex = 0; actMaterialIndex < materialList.Count; actMaterialIndex++)
            {
                result.CreateSurface();
            }

            // Now load the geometry itself
            var transformStack = new Matrix4Stack();

            foreach (var actObject in fileInfo.Objects)
            {
                FillGeometry(result, materialList, actObject, transformStack);
            }

            return(result);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Loads a ac file from the given uri
        /// </summary>
        internal static ACFileInfo LoadFile(Stream inStream)
        {
            ACFileInfo?  result = null;
            StreamReader?reader = null;

            try
            {
                reader = new StreamReader(inStream);

                //Check for correct header
                var header = reader.ReadLine();
                if (header == null ||
                    !header.StartsWith("AC3D"))
                {
                    throw new SeeingSharpGraphicsException("Header of AC3D file not found!");
                }

                //Create file information object
                result = new ACFileInfo();

                //Create a loaded objects stack
                var       loadedObjects  = new Stack <ACObjectInfo>();
                var       parentObjects  = new Stack <ACObjectInfo>();
                ACSurface?currentSurface = null;

                //Read the file
                while (!reader.EndOfStream)
                {
                    var actLine = reader.ReadLine() !.Trim();

                    var firstWord  = string.Empty;
                    var spaceIndex = actLine.IndexOf(' ');
                    if (spaceIndex == -1)
                    {
                        firstWord = actLine;
                    }
                    else
                    {
                        firstWord = firstWord = actLine.Substring(0, spaceIndex);
                    }

                    switch (firstWord)
                    {
                    //New Material info
                    case "MATERIAL":
                        var materialInfo = new ACMaterialInfo();
                        {
                            //Get the name of the material
                            var materialData = actLine.Split(' ');

                            if (materialData.Length > 1)
                            {
                                materialInfo.Name = materialData[1].Trim(' ', '"');
                            }

                            //Parse components
                            for (var loop = 0; loop < materialData.Length; loop++)
                            {
                                switch (materialData[loop])
                                {
                                case "rgb":
                                    var diffuseColor = materialInfo.Diffuse;
                                    diffuseColor.Alpha   = 1f;
                                    diffuseColor.Red     = float.Parse(materialData[loop + 1], CultureInfo.InvariantCulture);
                                    diffuseColor.Green   = float.Parse(materialData[loop + 2], CultureInfo.InvariantCulture);
                                    diffuseColor.Blue    = float.Parse(materialData[loop + 3], CultureInfo.InvariantCulture);
                                    materialInfo.Diffuse = diffuseColor;
                                    break;

                                case "amb":
                                    var ambientColor = new Color4();
                                    ambientColor.Red     = float.Parse(materialData[loop + 1], CultureInfo.InvariantCulture);
                                    ambientColor.Green   = float.Parse(materialData[loop + 2], CultureInfo.InvariantCulture);
                                    ambientColor.Blue    = float.Parse(materialData[loop + 3], CultureInfo.InvariantCulture);
                                    materialInfo.Ambient = ambientColor;
                                    break;

                                case "emis":
                                    var emissiveColor = new Color4();
                                    emissiveColor.Red     = float.Parse(materialData[loop + 1], CultureInfo.InvariantCulture);
                                    emissiveColor.Green   = float.Parse(materialData[loop + 2], CultureInfo.InvariantCulture);
                                    emissiveColor.Blue    = float.Parse(materialData[loop + 3], CultureInfo.InvariantCulture);
                                    materialInfo.Emissive = emissiveColor;
                                    break;

                                case "spec":
                                    var specularColor = new Color4();
                                    specularColor.Red     = float.Parse(materialData[loop + 1], CultureInfo.InvariantCulture);
                                    specularColor.Green   = float.Parse(materialData[loop + 2], CultureInfo.InvariantCulture);
                                    specularColor.Blue    = float.Parse(materialData[loop + 3], CultureInfo.InvariantCulture);
                                    materialInfo.Specular = specularColor;
                                    break;

                                case "shi":
                                    materialInfo.Shininess = float.Parse(materialData[loop + 1], CultureInfo.InvariantCulture);
                                    break;

                                case "trans":
                                    diffuseColor         = materialInfo.Diffuse;
                                    diffuseColor.Alpha   = 1f - EngineMath.Clamp(float.Parse(materialData[loop + 1], CultureInfo.InvariantCulture), 0f, 1f);
                                    materialInfo.Diffuse = diffuseColor;
                                    break;
                                }
                            }
                            result.Materials.Add(materialInfo);
                        }
                        break;

                    //New object starts here
                    case "OBJECT":
                    {
                        var newObject = new ACObjectInfo();

                        var lineData = actLine.Split(' ');
                        if (lineData[1] == "poly")
                        {
                            newObject.Type = ACObjectType.Poly;
                        }
                        else if (lineData[1] == "group")
                        {
                            newObject.Type = ACObjectType.Group;
                        }
                        else if (lineData[1] == "world")
                        {
                            newObject.Type = ACObjectType.World;
                        }

                        loadedObjects.Push(newObject);
                    }
                    break;

                    //End of an object, kids following
                    case "kids":
                        if (loadedObjects.Count == 0)
                        {
                            break;
                        }
                        {
                            //Parse kid count
                            var kidCount = 0;
                            var lineData = actLine.Split(' ');

                            if (lineData.Length >= 1)
                            {
                                int.TryParse(lineData[1], out kidCount);
                            }

                            var currentObject = loadedObjects.Peek();

                            if (currentObject != null)
                            {
                                //AddObject object to parent object, if any related
                                var addedToParent = false;

                                if (parentObjects.Count > 0)
                                {
                                    var currentParent = parentObjects.Peek();

                                    if (currentParent.Children.Count < currentParent.KidCount)
                                    {
                                        currentParent.Children.Add(currentObject);
                                        addedToParent = true;
                                    }
                                    else
                                    {
                                        while (parentObjects.Count > 0)
                                        {
                                            parentObjects.Pop();

                                            if (parentObjects.Count == 0)
                                            {
                                                break;
                                            }

                                            currentParent = parentObjects.Peek();

                                            if (currentParent == null)
                                            {
                                                break;
                                            }
                                            if (currentParent.Children.Count < currentParent.KidCount)
                                            {
                                                break;
                                            }
                                        }

                                        if (currentParent != null &&
                                            currentParent.Children.Count < currentParent.KidCount)
                                        {
                                            currentParent.Children.Add(currentObject);
                                            addedToParent = true;
                                        }
                                    }
                                }

                                //Enable this object as parent object
                                currentObject.KidCount = kidCount;

                                if (currentObject.KidCount > 0)
                                {
                                    parentObjects.Push(currentObject);
                                }

                                //AddObject to scene root if this object has no parent
                                loadedObjects.Pop();

                                if (!addedToParent)
                                {
                                    if (loadedObjects.Count == 0)
                                    {
                                        result.Objects.Add(currentObject);
                                    }
                                    else
                                    {
                                        loadedObjects.Peek().Children.Add(currentObject);
                                    }
                                }
                                currentObject = null;
                            }
                        }
                        break;

                    //Current object's name
                    case "name":
                        if (loadedObjects.Count == 0)
                        {
                            break;
                        }
                        {
                            var currentObject = loadedObjects.Peek();
                            if (currentObject != null)
                            {
                                currentObject.Name = actLine.Replace("name ", "").Replace("\"", "");
                            }
                        }
                        break;

                    case "data":
                        break;

                    case "texture":
                        if (loadedObjects.Count == 0)
                        {
                            break;
                        }
                        {
                            var currentObject = loadedObjects.Peek();

                            if (currentObject != null)
                            {
                                var lineData = actLine.Split(' ');
                                currentObject.Texture = lineData[1].Trim('"');
                            }
                        }
                        break;

                    case "texrep":
                        if (loadedObjects.Count == 0)
                        {
                            break;
                        }
                        {
                            var currentObject = loadedObjects.Peek();

                            if (currentObject != null)
                            {
                                var lineData = actLine.Split(' ');

                                var repetition = new Vector2
                                {
                                    X = float.Parse(lineData[1], CultureInfo.InvariantCulture),
                                    Y = float.Parse(lineData[2], CultureInfo.InvariantCulture)
                                };

                                currentObject.TextureRepeat = repetition;
                            }
                        }
                        break;

                    case "texoff":
                        if (loadedObjects.Count == 0)
                        {
                            break;
                        }
                        {
                            var currentObject = loadedObjects.Peek();

                            if (currentObject != null)
                            {
                                var lineData = actLine.Split(' ');

                                var offset = new Vector2
                                {
                                    X = float.Parse(lineData[1], CultureInfo.InvariantCulture),
                                    Y = float.Parse(lineData[2], CultureInfo.InvariantCulture)
                                };

                                currentObject.TextureRepeat = offset;
                            }
                        }
                        break;

                    case "rot":
                        if (loadedObjects.Count == 0)
                        {
                            break;
                        }
                        {
                            var currentObject = loadedObjects.Peek();

                            if (currentObject != null)
                            {
                                var lineData = actLine.Split(' ');

                                var rotation = Matrix4x4.Identity;
                                rotation.M11 = !string.IsNullOrEmpty(lineData[1]) ? float.Parse(lineData[1], CultureInfo.InvariantCulture) : 0f;
                                rotation.M12 = !string.IsNullOrEmpty(lineData[2]) ? float.Parse(lineData[2], CultureInfo.InvariantCulture) : 0f;
                                rotation.M13 = !string.IsNullOrEmpty(lineData[3]) ? float.Parse(lineData[3], CultureInfo.InvariantCulture) : 0f;
                                rotation.M21 = !string.IsNullOrEmpty(lineData[4]) ? float.Parse(lineData[4], CultureInfo.InvariantCulture) : 0f;
                                rotation.M22 = !string.IsNullOrEmpty(lineData[5]) ? float.Parse(lineData[5], CultureInfo.InvariantCulture) : 0f;
                                rotation.M23 = !string.IsNullOrEmpty(lineData[6]) ? float.Parse(lineData[6], CultureInfo.InvariantCulture) : 0f;
                                rotation.M31 = !string.IsNullOrEmpty(lineData[7]) ? float.Parse(lineData[7], CultureInfo.InvariantCulture) : 0f;
                                rotation.M32 = !string.IsNullOrEmpty(lineData[8]) ? float.Parse(lineData[8], CultureInfo.InvariantCulture) : 0f;
                                rotation.M33 = !string.IsNullOrEmpty(lineData[9]) ? float.Parse(lineData[9], CultureInfo.InvariantCulture) : 0f;

                                currentObject.Rotation = rotation;
                            }
                        }
                        break;

                    case "url":
                        if (loadedObjects.Count == 0)
                        {
                            break;
                        }
                        {
                            var currentObject = loadedObjects.Peek();

                            if (currentObject != null)
                            {
                                var lineData = actLine.Split(' ');
                                currentObject.Url = lineData[1].Trim('"');
                            }
                        }
                        break;

                    //Current object's location
                    case "loc":
                        if (loadedObjects.Count == 0)
                        {
                            break;
                        }
                        {
                            var currentObject = loadedObjects.Peek();

                            if (currentObject != null)
                            {
                                var lineData = actLine.Split(' ');

                                var location = new Vector3
                                {
                                    X = float.Parse(lineData[1], CultureInfo.InvariantCulture),
                                    Y = float.Parse(lineData[2], CultureInfo.InvariantCulture),
                                    Z = float.Parse(lineData[3], CultureInfo.InvariantCulture)
                                };

                                currentObject.Translation = location;
                            }
                        }
                        break;

                    case "numvert":
                        if (loadedObjects.Count == 0)
                        {
                            break;
                        }
                        {
                            var currentObject = loadedObjects.Peek();

                            if (currentObject != null)
                            {
                                var lineData         = actLine.Split(' ');
                                var numberOfVertices = int.Parse(lineData[1], CultureInfo.InvariantCulture);

                                for (var loop = 0; loop < numberOfVertices; loop++)
                                {
                                    var actInnerLine   = reader.ReadLine() !.Trim();
                                    var splittedVertex = actInnerLine.Split(' ');

                                    var position = new Vector3
                                    {
                                        X = float.Parse(splittedVertex[0], CultureInfo.InvariantCulture),
                                        Y = float.Parse(splittedVertex[1], CultureInfo.InvariantCulture),
                                        Z = float.Parse(splittedVertex[2], CultureInfo.InvariantCulture)
                                    };

                                    currentObject.Vertices.Add(new ACVertex {
                                        Position = position
                                    });
                                }
                            }
                        }
                        break;

                    //Start of a list of surfaces
                    case "numsurf":
                        break;

                    //New surface starts here
                    case "SURF":
                    {
                        if (currentSurface == null)
                        {
                            currentSurface = new ACSurface();
                        }

                        var lineData = actLine.Split(' ');
                        lineData[1]          = lineData[1].Substring(2);
                        currentSurface.Flags = int.Parse(lineData[1], NumberStyles.HexNumber);
                    }
                    break;

                    //Current surface's material
                    case "mat":
                    {
                        if (currentSurface == null)
                        {
                            currentSurface = new ACSurface();
                        }

                        var lineData = actLine.Split(' ');
                        currentSurface.Material = int.Parse(lineData[1], CultureInfo.InvariantCulture);
                    }
                    break;

                    //Current surface's indices
                    case "refs":
                        if (loadedObjects.Count == 0)
                        {
                            break;
                        }
                        {
                            if (currentSurface == null)
                            {
                                currentSurface = new ACSurface();
                            }

                            var lineData     = actLine.Split(' ');
                            var numberOfRefs = int.Parse(lineData[1], CultureInfo.InvariantCulture);

                            for (var loop = 0; loop < numberOfRefs; loop++)
                            {
                                var actInnerLine = reader.ReadLine() !.Trim();
                                var splittedRef  = actInnerLine.Split(' ');

                                var texCoord        = new Vector2();
                                int vertexReference = ushort.Parse(splittedRef[0], CultureInfo.InvariantCulture);
                                texCoord.X = float.Parse(splittedRef[1], CultureInfo.InvariantCulture);
                                texCoord.Y = float.Parse(splittedRef[2], CultureInfo.InvariantCulture);

                                currentSurface.TextureCoordinates.Add(texCoord);
                                currentSurface.VertexReferences.Add(vertexReference);
                            }

                            var currentObject = loadedObjects.Peek();

                            currentObject?.Surfaces.Add(currentSurface);

                            currentSurface = null;
                        }
                        break;
                    }
                }
            }
            finally
            {
                SeeingSharpUtil.SafeDispose(ref reader);
            }

            return(result);
        }