Exemplo n.º 1
0
        public override void GenPatches(GameObject parent,
                Vector2f origin,
                Vector2f center,
                int numChunks,
                int numEntityPerChunk,
                float parentSize)
        {
            float chunkSize = parentSize / ((float)numChunks);

            Vector2f max = new Vector2f((numChunks) * chunkSize);
            max.DivideStore(2);

            for (int x = 0; x < numChunks; x++)
            {
                for (int z = 0; z < numChunks; z++)
                {
                    Vector2f offset = new Vector2f(x * chunkSize, z * chunkSize);
                    Vector2f chunkLoc = origin.Add(offset).SubtractStore(max);
                    GridTile tile = new GridTile(chunkLoc, chunkSize, chunkSize, chunkLoc.x, chunkLoc.y, 50f);
                    Patch patch = new Patch( (Node)parent, tile);

                    patch.translation = new Vector3f(chunkLoc.x, 0, chunkLoc.y);
                    patch.chunkSize = chunkSize;
                    patch.entityPerChunk = numEntityPerChunk;

                    patches.Add(patch);
                }
            }
        }
        public SimplexTerrainComponent(PhysicsWorld physicsWorld)
            : base(physicsWorld)
        {
            rHeights = new float[4];
            int numberOfOctaves = 8;
            octaves = new OpenSimplexNoise[numberOfOctaves];
            frequencys = new double[numberOfOctaves];
            amplitudes = new double[numberOfOctaves];
            for (int i = 0; i < 8; i++)
                tmpVec[i] = new Vector2f();

            for (int i = 0; i < numberOfOctaves; i++)
            {
                octaves[i] = new OpenSimplexNoise(666);
                frequencys[i] = (float)System.Math.Pow(2, i);
                amplitudes[i] = (float)System.Math.Pow(0.5f, octaves.Length - i);
            }

            //Texture splat = AssetManager.LoadTexture("C:\\Users\\User\\Desktop\\test_0_1.png");
            ///terrainMaterial.SetValue(TerrainMaterial.TEXTURE_SPLAT, splat);

            //terrainMaterial.SetValue(Material.COLOR_DIFFUSE, new Vector4f(0.2f, 0.7f, 0.2f, 1.0f));
            Texture grass = AssetManager.LoadTexture(Assets.AssetManager.GetAppPath() + "\\textures\\grass4.jpg");
            Texture grass_nrm = AssetManager.LoadTexture(Assets.AssetManager.GetAppPath() + "\\textures\\grass_NRM.jpg");
            Texture dirt = AssetManager.LoadTexture(Assets.AssetManager.GetAppPath() + "\\textures\\dirt.jpg");
            Texture dirt_nrm = AssetManager.LoadTexture(Assets.AssetManager.GetAppPath() + "\\textures\\dirt_NRM.jpg");
            terrainMaterial.SetValue(TerrainMaterial.TEXTURE_DIFFUSE0, grass);
            terrainMaterial.SetValue(TerrainMaterial.TEXTURE_NORMAL0, grass_nrm);
            terrainMaterial.SetValue(TerrainMaterial.TEXTURE_DIFFUSE_SLOPE, dirt);
            terrainMaterial.SetValue(TerrainMaterial.TEXTURE_NORMAL_SLOPE, dirt_nrm);
            terrainMaterial.SetValue(Material.MATERIAL_CASTSHADOWS, false);
            terrainMaterial.SetValue(Material.SHININESS, 0.1f);
            terrainMaterial.SetValue(Material.ROUGHNESS, 0.08f);
        }
Exemplo n.º 3
0
 public GridTile(Vector2f center, float width, float length, float x, float z, float maxDistance)
 {
     this.center = new Vector2f(x + (width / 2f), z + (length / 2f));
     this.width = width;
     this.length = length;
     this.x = x;
     this.z = z;
     this.maxDistance = maxDistance;
 }
Exemplo n.º 4
0
 public Vertex(Vertex other)
 {
     this.position = other.position;
     this.normal = other.normal;
     this.texCoord0 = other.texCoord0;
     this.texCoord1 = other.texCoord1;
     this.tangent = other.tangent;
     this.bitangent = other.bitangent;
     for (int i = 0; i < 4; i++)
     {
         this.boneIndices[i] = other.boneIndices[i];
         this.boneWeights[i] = other.boneWeights[i];
     }
 }
Exemplo n.º 5
0
 public HeightInfo(TerrainComponent component, Vector2f pos, TerrainChunkNode chunk)
 {
     this.position = pos;
     this.chunk = chunk;
     this.component = component;
 }
Exemplo n.º 6
0
 public void SetUniform(string name, Vector2f[] vec)
 {
     for (int i = 0; i < vec.Length; i++)
         SetUniform(name + "[" + i.ToString() + "]", vec[i].X, vec[i].Y);
 }
Exemplo n.º 7
0
 protected Vector2f ScaleDivide(Vector2f a)
 {
     return a.Multiply(1f / ((int)chunkSize - 1)).Multiply(new Vector2f(scale.x, scale.z));
 }
Exemplo n.º 8
0
 public bool inRange(Vector2f point)
 {
     float dist = center.Distance(point);
     return dist < maxDistance;
 }
Exemplo n.º 9
0
 public void SetUniform(string name, Vector2f vec)
 {
     SetUniform(name, vec.X, vec.Y);
 }
Exemplo n.º 10
0
        public override object Load(LoadedAsset asset)
        {
            XmlReader xmlReader = XmlReader.Create(asset.Data);
            while (xmlReader.Read())
            {
                if (xmlReader.NodeType == XmlNodeType.Element)
                {
                    if (xmlReader.Name == ApxExporter.TOKEN_NODE)
                    {
                        node = true;
                        geom = false;
                        string name = xmlReader.GetAttribute(ApxExporter.TOKEN_NAME);
                        Node n = new Node(name);
                        if (lastNode != null)
                            lastNode.AddChild(n);
                        lastNode = n;
                        nodes.Add(n);
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_GEOMETRY)
                    {
                        node = false;
                        geom = true;
                        string name = xmlReader.GetAttribute(ApxExporter.TOKEN_NAME);
                        Geometry g = new Geometry();
                        g.Name = name;
                        if (lastNode != null)
                            lastNode.AddChild(g);
                        geoms.Add(g);
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_MATERIAL)
                    {
                        Material mat = new Material();
                        mats.Add(mat);
                        string bucketStr = xmlReader.GetAttribute(ApxExporter.TOKEN_MATERIAL_BUCKET);
                        RenderManager.Bucket bucket;
                        if (bucketStr != null)
                            Enum.TryParse<RenderManager.Bucket>(bucketStr, out bucket);
                        else
                            bucket = RenderManager.Bucket.Opaque;
                        Console.WriteLine("Bucket: " + bucket.ToString());
                        mat.Bucket = bucket;
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_MATERIAL_PROPERTY)
                    {
                        Material lastMaterial = mats[mats.Count - 1];

                        string name = xmlReader.GetAttribute(ApxExporter.TOKEN_NAME);
                        string type = xmlReader.GetAttribute(ApxExporter.TOKEN_TYPE);
                        string val = xmlReader.GetAttribute(ApxExporter.TOKEN_VALUE);

                        object value = null;
                        if (type == ApxExporter.TOKEN_TYPE_STRING)
                            value = val;
                        else if (type == ApxExporter.TOKEN_TYPE_INT)
                            value = int.Parse(val);
                        else if (type == ApxExporter.TOKEN_TYPE_BOOLEAN)
                            value = bool.Parse(val);
                        else if (type == ApxExporter.TOKEN_TYPE_FLOAT)
                            value = float.Parse(val);
                        else if (type == ApxExporter.TOKEN_TYPE_VECTOR2)
                            value = ParseVector2(val);
                        else if (type == ApxExporter.TOKEN_TYPE_VECTOR3)
                            value = ParseVector3(val);
                        else if (type == ApxExporter.TOKEN_TYPE_VECTOR4)
                            value = ParseVector4(val);
                        else if (type == ApxExporter.TOKEN_TYPE_TEXTURE)
                        {
                            string texPath = val;
                            string parentPath = System.IO.Directory.GetParent(asset.FilePath).ToString();
                            string finalTexPath = parentPath + "\\" + texPath;
                            if (System.IO.File.Exists(finalTexPath))
                            {
                                value = AssetManager.LoadTexture(finalTexPath);
                            }
                            else if (System.IO.File.Exists(texPath)) // absolute path
                            {
                                value = AssetManager.LoadTexture(texPath);
                            }
                            else
                                value = null;
                        }

                        lastMaterial.SetValue(name, value);
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_TRANSLATION)
                    {
                        float x = float.Parse(xmlReader.GetAttribute("x"));
                        float y = float.Parse(xmlReader.GetAttribute("y"));
                        float z = float.Parse(xmlReader.GetAttribute("z"));

                        Vector3f vec = new Vector3f(x, y, z);
                        GameObject go = null;
                        if (node)
                            go = nodes[nodes.Count - 1];
                        else if (geom)
                            go = geoms[geoms.Count - 1];
                        go.SetLocalTranslation(vec);
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_ROTATION)
                    {
                        float x = float.Parse(xmlReader.GetAttribute("x"));
                        float y = float.Parse(xmlReader.GetAttribute("y"));
                        float z = float.Parse(xmlReader.GetAttribute("z"));
                        float w = float.Parse(xmlReader.GetAttribute("w"));

                        Quaternion quat = new Quaternion(x, y, z, w);
                        GameObject go = null;
                        if (node)
                            go = nodes[nodes.Count - 1];
                        else if (geom)
                            go = geoms[geoms.Count - 1];
                        go.SetLocalRotation(quat);
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_SCALE)
                    {
                        float x = float.Parse(xmlReader.GetAttribute("x"));
                        float y = float.Parse(xmlReader.GetAttribute("y"));
                        float z = float.Parse(xmlReader.GetAttribute("z"));

                        Vector3f vec = new Vector3f(x, y, z);
                        GameObject go = null;
                        if (node)
                            go = nodes[nodes.Count - 1];
                        else if (geom)
                            go = geoms[geoms.Count - 1];
                        go.SetLocalScale(vec);
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_MESH)
                    {
                        meshes.Add(new Mesh());
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_VERTICES)
                    {
                        List<Vertex> newVList = new List<Vertex>();
                        vertices.Add(newVList);

                        List<Vector3f> newPList = new List<Vector3f>();
                        positions.Add(newPList);

                        List<Vector3f> newNList = new List<Vector3f>();
                        normals.Add(newNList);

                        List<Vector2f> newT0List = new List<Vector2f>();
                        texcoords0.Add(newT0List);

                        List<Vector2f> newT1List = new List<Vector2f>();
                        texcoords1.Add(newT1List);
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_POSITION)
                    {
                        List<Vector3f> pos = positions[positions.Count - 1];

                        float x = float.Parse(xmlReader.GetAttribute("x"));
                        float y = float.Parse(xmlReader.GetAttribute("y"));
                        float z = float.Parse(xmlReader.GetAttribute("z"));

                        Vector3f position = new Vector3f(x, y, z);
                        pos.Add(position);
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_NORMAL)
                    {
                        List<Vector3f> nor = normals[normals.Count - 1];

                        float x = float.Parse(xmlReader.GetAttribute("x"));
                        float y = float.Parse(xmlReader.GetAttribute("y"));
                        float z = float.Parse(xmlReader.GetAttribute("z"));

                        Vector3f normal = new Vector3f(x, y, z);
                        nor.Add(normal);
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_TEXCOORD0)
                    {
                        List<Vector2f> tc0 = texcoords0[texcoords0.Count - 1];

                        float x = float.Parse(xmlReader.GetAttribute("x"));
                        float y = float.Parse(xmlReader.GetAttribute("y"));

                        Vector2f tc = new Vector2f(x, y);
                        tc0.Add(tc);
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_TEXCOORD1)
                    {
                        List<Vector2f> tc1 = texcoords1[texcoords1.Count - 1];

                        float x = float.Parse(xmlReader.GetAttribute("x"));
                        float y = float.Parse(xmlReader.GetAttribute("y"));

                        Vector2f tc = new Vector2f(x, y);
                        tc1.Add(tc);
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_FACES)
                    {
                        faces.Add(new List<int>());
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_FACE)
                    {
                        List<int> fList = faces[faces.Count - 1];
                        for (int i = 0; i < 3; i++)
                        {
                            string val = xmlReader.GetAttribute("i" + i.ToString());
                            if (val != "")
                            {
                                string[] tokens = val.Split('/');
                                for (int j = 0; j < tokens.Length; j++)
                                {
                                    fList.Add(int.Parse(tokens[j]));
                                }
                            }
                        }
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_SKELETON)
                    {
                        skeletons.Add(new Skeleton());
                        bones.Add(new List<Bone>());
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_SKELETON_ASSIGN)
                    {
                        string assign = xmlReader.GetAttribute(ApxExporter.TOKEN_ID);
                        skeletonAssigns.Add(int.Parse(assign));
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_BONE)
                    {
                        string name = xmlReader.GetAttribute(ApxExporter.TOKEN_NAME);
                        string parent = xmlReader.GetAttribute(ApxExporter.TOKEN_PARENT);
                        Bone bone = new Bone(name);
                        List<Bone> lastBL = bones[bones.Count - 1];
                        if (!string.IsNullOrEmpty(parent))
                        {
                            foreach (Bone b in lastBL)
                            {
                                if (b.Name == parent)
                                {
                                    b.AddChild(bone);
                                }
                            }
                        }
                        List<Bone> skel = bones[bones.Count - 1];
                        skel.Add(bone);
                        Skeleton lastSkeleton = skeletons[skeletons.Count - 1];
                        lastSkeleton.AddBone(bone);
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_BONE_BINDPOSITION)
                    {
                        float x = float.Parse(xmlReader.GetAttribute("x"));
                        float y = float.Parse(xmlReader.GetAttribute("y"));
                        float z = float.Parse(xmlReader.GetAttribute("z"));

                        Vector3f vec = new Vector3f(x, y, z);
                        List<Bone> skel = bones[bones.Count - 1];
                        if (skel.Count > 0)
                        {
                            Bone lastBone = skel[skel.Count - 1];
                            lastBone.SetBindTranslation(vec);
                        }
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_BONE_BINDROTATION)
                    {
                        float x = float.Parse(xmlReader.GetAttribute("x"));
                        float y = float.Parse(xmlReader.GetAttribute("y"));
                        float z = float.Parse(xmlReader.GetAttribute("z"));
                        float w = float.Parse(xmlReader.GetAttribute("w"));

                        List<Bone> skel = bones[bones.Count - 1];
                        if (skel.Count > 0)
                        {
                            Bone lastBone = skel[skel.Count - 1];
                            //   lastBone.SetBindAxisAngle(new Vector3f(x, y, z), w);
                            lastBone.SetBindRotation(new Quaternion(x, y, z, w));
                        }
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_BONE_ASSIGNS)
                    {
                        boneAssigns.Add(new List<BoneAssign>());
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_BONE_ASSIGN)
                    {
                        int vertIdx = int.Parse(xmlReader.GetAttribute(ApxExporter.TOKEN_VERTEXINDEX));
                        int boneIdx = int.Parse(xmlReader.GetAttribute(ApxExporter.TOKEN_BONEINDEX));
                        float boneWeight = float.Parse(xmlReader.GetAttribute(ApxExporter.TOKEN_BONEWEIGHT));
                        List<BoneAssign> ba = boneAssigns[boneAssigns.Count - 1];
                        ba.Add(new BoneAssign(vertIdx, boneWeight, boneIdx));
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_ANIMATIONS)
                    {
                        hasAnimations = true;
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_ANIMATION)
                    {
                        string name = xmlReader.GetAttribute(ApxExporter.TOKEN_NAME);
                        Animation anim = new Animation(name);
                        animations.Add(anim);
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_ANIMATION_TRACK)
                    {
                        string bone = xmlReader.GetAttribute(ApxExporter.TOKEN_BONE);
                        Bone b = skeletons[skeletons.Count - 1].GetBone(bone);
                        if (b != null)
                        {
                            AnimationTrack track = new AnimationTrack(b);
                            animations[animations.Count - 1].AddTrack(track);
                        }
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_KEYFRAME)
                    {
                        float time = float.Parse(xmlReader.GetAttribute(ApxExporter.TOKEN_TIME));

                        Keyframe frame = new Keyframe(time, null, null);
                        Animation canim = animations[animations.Count - 1];
                        AnimationTrack ctrack = canim.GetTrack(canim.GetTracks().Count - 1);
                        ctrack.AddKeyframe(frame);
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_KEYFRAME_TRANSLATION)
                    {
                        Animation canim = animations[animations.Count - 1];
                        AnimationTrack ctrack = canim.GetTrack(canim.GetTracks().Count - 1);
                        Keyframe lastFrame = ctrack.frames[ctrack.frames.Count - 1];

                        float x = float.Parse(xmlReader.GetAttribute("x"));
                        float y = float.Parse(xmlReader.GetAttribute("y"));
                        float z = float.Parse(xmlReader.GetAttribute("z"));

                        Vector3f vec = new Vector3f(x, y, z);
                        lastFrame.SetTranslation(vec);
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_KEYFRAME_ROTATION)
                    {
                        Animation canim = animations[animations.Count - 1];
                        AnimationTrack ctrack = canim.GetTrack(canim.GetTracks().Count - 1);
                        Keyframe lastFrame = ctrack.frames[ctrack.frames.Count - 1];

                        float x = float.Parse(xmlReader.GetAttribute("x"));
                        float y = float.Parse(xmlReader.GetAttribute("y"));
                        float z = float.Parse(xmlReader.GetAttribute("z"));
                        float w = float.Parse(xmlReader.GetAttribute("w"));

                        Quaternion rot = new Quaternion(x, y, z, w);
                        lastFrame.SetRotation(rot);
                    }
                } // start element
                else if (xmlReader.NodeType == XmlNodeType.EndElement)
                {
                    if (xmlReader.Name == ApxExporter.TOKEN_NODE)
                    {
                        if (lastNode != null)
                        {
                            if (lastNode.GetParent() != null)
                            {
                                lastNode = lastNode.GetParent();
                            }
                            else
                            {
                                lastNode = null;
                            }
                        }
                        node = false;
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_GEOMETRY)
                    {
                        geom = false;
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_MATERIAL)
                    {
                        if (geoms.Count > 0)
                        {
                            int lastGeomIndex = geoms.Count - 1;
                            Geometry parent = geoms[lastGeomIndex];
                            int lastMatIndex = mats.Count - 1;
                            Material m = mats[lastMatIndex];
                            geomMats.Add(parent, m);
                        }
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_SKELETON)
                    {
                    }
                    else if (xmlReader.Name == ApxExporter.TOKEN_MODEL)
                    {
                        // end of model, load in meshes
                        EndModel();
                    }
                } // end element
            }
            xmlReader.Close();
            Node finalNode = new Node();
            foreach (Node n in nodes)
                if (n.GetParent() == null)
                    finalNode.AddChild(n);
            this.ResetLoader();
            return finalNode;
        }
Exemplo n.º 11
0
        private void AddChunk(int x, int z)
        {
            HeightInfo hi = HmWithCoords(x, z);

            if (hi == null)
            {
                Vector2f vec = new Vector2f(x, z);
                if (vec.Distance(this.v2cp) < maxDist)
                {
                    TerrainChunkNode hmtc = CreateNewChunk(physicsWorld, this, x, z, scale, chunkSize, null);

                    heightmaps.Add(hi = new HeightInfo(this, vec, hmtc));
                    hi.chunk.Create();
                    ApplyTerrainMaterial(hmtc);
                    hi.chunk.SetLocalTranslation(new Vector3f(x * (chunkSize - 1) * scale.x, 0, z * (chunkSize - 1) * scale.z));
                    hi.midpoint = new Vector2f(hi.chunk.GetLocalTranslation().x - ((chunkSize - 1) * scale.x / 2), hi.chunk.GetLocalTranslation().z - (chunkSize - 1) * scale.z / 2);

                    Vector2f[] neighbors = GetNeighbors(hi);
                    hi.neighbors = neighbors;
                    rootNode.AddChild(hi.chunk);

                    hi.pageState = PageState.Loaded;
                }
            }
            else
            {
            }
        }
Exemplo n.º 12
0
 public abstract void GenPatches(GameObject parent,
         Vector2f origin,
         Vector2f center,
         int numChunks,
         int numEntityPerChunk,
         float parentSize);
Exemplo n.º 13
0
 protected Vector2f[] GetNeighbors(HeightInfo origin)
 {
     Vector2f[] nb = new Vector2f[8];
     nb[0] = new Vector2f(origin.position.x + 1, origin.position.y);
     nb[1] = new Vector2f(origin.position.x - 1, origin.position.y);
     nb[2] = new Vector2f(origin.position.x, origin.position.y + 1);
     nb[3] = new Vector2f(origin.position.x, origin.position.y - 1);
     nb[4] = new Vector2f(origin.position.x + 1, origin.position.y - 1);
     nb[5] = new Vector2f(origin.position.x - 1, origin.position.y - 1);
     nb[6] = new Vector2f(origin.position.x + 1, origin.position.y + 1);
     nb[7] = new Vector2f(origin.position.x - 1, origin.position.y - 1);
     return nb;
 }
Exemplo n.º 14
0
 public Vertex(Vector3f pos, Vector2f tc0, Vector3f norm)
 {
     position = pos;
     texCoord0 = tc0;
     normal = norm;
 }
Exemplo n.º 15
0
 public Vertex(Vector3f pos, Vector2f tc0)
 {
     position = pos;
     texCoord0 = tc0;
 }
Exemplo n.º 16
0
 public void SetTexCoord1(Vector2f tc1)
 {
     texCoord0 = tc1;
 }
Exemplo n.º 17
0
 public void SetTexCoord0(Vector2f tc0)
 {
     texCoord0 = tc0;
 }
Exemplo n.º 18
0
        public override object Load(LoadedAsset asset)
        {
            XmlReader xmlReader = XmlReader.Create(asset.Data);
            while (xmlReader.Read())
            {
                if (xmlReader.NodeType == XmlNodeType.Element)
                {
                    if (xmlReader.Name == "position")
                    {
                        float x = float.Parse(xmlReader.GetAttribute("x"));
                        float y = float.Parse(xmlReader.GetAttribute("y"));
                        float z = float.Parse(xmlReader.GetAttribute("z"));
                        Vector3f vec = new Vector3f(x, y, z);
                        positions.Add(vec);
                    }
                    else if (xmlReader.Name == "normal")
                    {
                        float x = float.Parse(xmlReader.GetAttribute("x"));
                        float y = float.Parse(xmlReader.GetAttribute("y"));
                        float z = float.Parse(xmlReader.GetAttribute("z"));
                        Vector3f vec = new Vector3f(x, y, z);
                        normals.Add(vec);
                    }
                    else if (xmlReader.Name == "texcoord")
                    {
                        float x = float.Parse(xmlReader.GetAttribute(0));
                        float y = float.Parse(xmlReader.GetAttribute(1));
                        Vector2f tc = new Vector2f(x, -y);
                        texCoords.Add(tc);
                    }
                    else if (xmlReader.Name == "face")
                    {
                        if (!useSubmeshes)
                        {
                            faces.Add(int.Parse(xmlReader.GetAttribute(0)));
                            faces.Add(int.Parse(xmlReader.GetAttribute(1)));
                            faces.Add(int.Parse(xmlReader.GetAttribute(2)));
                        }
                        else if (useSubmeshes)
                        {
                            CurrentSubmesh().faces.Add(int.Parse(xmlReader.GetAttribute(0)));
                            CurrentSubmesh().faces.Add(int.Parse(xmlReader.GetAttribute(1)));
                            CurrentSubmesh().faces.Add(int.Parse(xmlReader.GetAttribute(2)));
                        }
                    }
                    else if (xmlReader.Name == "skeletonlink")
                    {
                        string parentPath = System.IO.Directory.GetParent(asset.FilePath).ToString();
                        string skeletonPath = parentPath + "\\" + xmlReader.GetAttribute(0) + ".xml";
                        skeleton = (Skeleton)AssetManager.Load(skeletonPath, OgreXmlSkeletonLoader.GetInstance());
                    }
                    else if (xmlReader.Name == "vertexboneassignment" || xmlReader.Name == "boneassignment")
                    {
                        int vidx = int.Parse(xmlReader.GetAttribute("vertexindex"));
                        float boneWeight = float.Parse(xmlReader.GetAttribute("weight"));
                        int boneIndex = int.Parse(xmlReader.GetAttribute("boneindex"));
                        AddToBoneAssigns(vidx, new BoneAssign(vidx, boneWeight, boneIndex));
                    }
                    else if (xmlReader.Name == "submesh")
                    {
                        useSubmeshes = true;
                        if (xmlReader.GetAttribute("operationtype") != null)
                        {
                            // material
                            Submesh sm = new Submesh();
                            subMeshes.Add(sm);
                        }
                    }
                }
            }
            xmlReader.Close();
            List<Vertex> vertices = new List<Vertex>();
            if (!useSubmeshes)
            {
                LoopThrough(faces, ref vertices);
            }
            else
            {
                for (int i = subMeshes.Count - 1; i > -1; i--)
                {
                    Submesh s = subMeshes[i];
                    if (s.faces.Count > 0)
                        LoopThrough(s.faces, ref s.vertices);
                    else
                        subMeshes.Remove(s);
                }
            }

            if (skeleton.GetNumBones() > 0)
            {
                for (int i = 0; i < skeleton.GetNumBones(); i++)
                    skeleton.GetBone(i).SetToBindingPose();
                skeleton.GetBone(0).CalculateBindingRotation();
                skeleton.GetBone(0).CalculateBindingTranslation();
                for (int i = 0; i < skeleton.GetNumBones(); i++)
                {
                    skeleton.GetBone(i).StoreBindingPose();
                    skeleton.GetBone(i).ClearPose();
                }
                skeleton.GetBone(0).UpdateTransform();
            }
            bool hasAnimations = skeleton.GetAnimations().Count > 0;
            AnimationController animControl = new AnimationController(skeleton);
            Node res = new Node();
            if (!useSubmeshes)
            {
                Mesh mesh = new Mesh();
                mesh.SetSkeleton(skeleton);
                mesh.SetVertices(vertices);
                Geometry geom = new Geometry();
                geom.Mesh = mesh;
                res.AddChild(geom);
            }
            else
            {
                for (int i = 0; i < subMeshes.Count; i++)
                {
                    Submesh sm = subMeshes[i];

                    Mesh mesh = new Mesh();
                    mesh.SetSkeleton(skeleton);
                    mesh.SetVertices(sm.vertices);
                    Geometry geom = new Geometry();
                    geom.Mesh = mesh;
                    res.AddChild(geom);
                }
            }
            if (hasAnimations)
            {
                res.AddController(animControl);
            }
            ResetLoader();
            return res;
        }
Exemplo n.º 19
0
 public Vector3f Unproject(Vector2f mouseXY)
 {
     return Unproject(mouseXY.X, mouseXY.Y);
 }
Exemplo n.º 20
0
 protected void AddToQueue(Vector2f chunk)
 {
     queue.Add(chunk);
 }