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);
}
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;
}
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];
}
}
public HeightInfo(TerrainComponent component, Vector2f pos, TerrainChunkNode chunk)
{
this.position = pos;
this.chunk = chunk;
this.component = component;
}
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);
}
protected Vector2f ScaleDivide(Vector2f a)
{
return a.Multiply(1f / ((int)chunkSize - 1)).Multiply(new Vector2f(scale.x, scale.z));
}
public bool inRange(Vector2f point)
{
float dist = center.Distance(point);
return dist < maxDistance;
}
public void SetUniform(string name, Vector2f vec)
{
SetUniform(name, vec.X, vec.Y);
}
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;
}
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
{
}
}
public abstract void GenPatches(GameObject parent,
Vector2f origin,
Vector2f center,
int numChunks,
int numEntityPerChunk,
float parentSize);
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;
}
public Vertex(Vector3f pos, Vector2f tc0, Vector3f norm)
{
position = pos;
texCoord0 = tc0;
normal = norm;
}
public Vertex(Vector3f pos, Vector2f tc0)
{
position = pos;
texCoord0 = tc0;
}
public void SetTexCoord1(Vector2f tc1)
{
texCoord0 = tc1;
}
public void SetTexCoord0(Vector2f tc0)
{
texCoord0 = tc0;
}
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;
}
public Vector3f Unproject(Vector2f mouseXY)
{
return Unproject(mouseXY.X, mouseXY.Y);
}
protected void AddToQueue(Vector2f chunk)
{
queue.Add(chunk);
}
