public override IResource create(ResourceManager mgr)
{
ObjModelDescriptor desc = new ObjModelDescriptor(Path.Combine(path, (string)descriptor["mesh"]));
Model dome = Renderer.resourceManager.getResource(desc) as Model;
dome.myMeshes[0].material = new Material(name);
dome.myMeshes[0].material.myFeatures |= Material.Feature.Skydome;
TextureDescriptor td = new TextureDescriptor(Path.Combine(path, (string)descriptor["sun"]), true);
Texture t = Renderer.resourceManager.getResource(td) as Texture;
dome.myMeshes[0].material.addAttribute(new TextureAttribute("sun", t));
td = new TextureDescriptor(Path.Combine(path, (string)descriptor["tint1"]), true);
t = Renderer.resourceManager.getResource(td) as Texture;
dome.myMeshes[0].material.addAttribute(new TextureAttribute("tint1", t));
td = new TextureDescriptor(Path.Combine(path, (string)descriptor["tint2"]), true);
t = Renderer.resourceManager.getResource(td) as Texture;
dome.myMeshes[0].material.addAttribute(new TextureAttribute("tint2", t));
td = new TextureDescriptor(Path.Combine(path, (string)descriptor["clouds1"]), true);
t = Renderer.resourceManager.getResource(td) as Texture;
dome.myMeshes[0].material.addAttribute(new TextureAttribute("clouds1", t));
td = new TextureDescriptor(Path.Combine(path, (string)descriptor["clouds2"]), true);
t = Renderer.resourceManager.getResource(td) as Texture;
dome.myMeshes[0].material.addAttribute(new TextureAttribute("clouds2", t));
td = new TextureDescriptor(Path.Combine(path, (string)descriptor["moon"]), true);
t = Renderer.resourceManager.getResource(td) as Texture;
dome.myMeshes[0].material.addAttribute(new TextureAttribute("moon", t));
return(dome);
}
public static ParticleSystem createSystem(JsonObject initData)
{
ParticleSystem ps = new ParticleSystem();
ps.continuous = (bool)initData["continuous"];
ps.lifetime = (float)initData["lifetime"];
ps.maxParticles = (int)initData["maxParticles"];
String textureName = (string)initData["material"];
TextureDescriptor td = new TextureDescriptor(textureName);
ps.material = Renderer.resourceManager.getResource(td) as Texture;
JsonObject features = initData["features"];
foreach (String key in features.keys)
{
ParticleFeatureCreator creator = null;
if (featureFactory.TryGetValue(key, out creator) == true)
{
JsonObject featureData = features[key];
ParticleFeature f = creator.create(featureData);
ps.addFeature(f);
}
else
{
//don't get here
throw new Exception(String.Format("Unable to find creator for {0}", key));
}
}
addParticleSystem(ps);
return(ps);
}
Texture findTexture(String textureName)
{
//get the texture for this group
String texFilename = Path.GetFileName(textureName);
String modelPath = Path.GetDirectoryName(myFilename);
textureName = Path.Combine(modelPath, texFilename);
TextureDescriptor td = new TextureDescriptor(textureName);
Texture t = myResourceManager.getResource(td) as Texture;
return(t);
}
Texture getTexture(string filepath)
{
Texture t = null;
TextureDescriptor td = new TextureDescriptor(Path.Combine(myRootPath, filepath), true);
t = myResourceManager.getResource(td) as Texture;
if (t == null)
{
Warn.print("Failed to load texture {0}", filepath);
}
return(t);
}
public TextureFont(String name, String textureName, int size)
: base(name, size)
{
TextureDescriptor td = new TextureDescriptor(textureName, true);
texture = Renderer.resourceManager.getResource(td) as Texture;
buildFont();
//set shader
List <ShaderDescriptor> desc = new List <ShaderDescriptor>();
desc.Add(new ShaderDescriptor(ShaderType.VertexShader, "..\\src\\Graphics\\shaders\\font-vs.glsl", ShaderDescriptor.Source.File));
desc.Add(new ShaderDescriptor(ShaderType.FragmentShader, "..\\src\\Graphics\\shaders\\font-ps.glsl", ShaderDescriptor.Source.File));
ShaderProgramDescriptor shDesc = new ShaderProgramDescriptor(desc);
myShader = Renderer.resourceManager.getResource(shDesc) as ShaderProgram;
myVao.bindVertexFormat <V3T2>(myShader);
}
protected Texture getTexture(string filepath)
{
Texture t = null;
if (filepath[0] == '*') //this is an embedded texture
{
string textureIndexStr = filepath.TrimStart('*');
int index = Convert.ToInt32(textureIndexStr);
if (index >= myScene.TextureCount)
{
Warn.print("texture index({0}) is out of range({1})", index, myScene.TextureCount);
return(null);
}
EmbeddedTexture texData = myScene.Textures[index];
if (texData != null)
{
if (texData.IsCompressed)
{
byte[] bytes = texData.CompressedData;
switch (texData.CompressedFormatHint)
{
case "png": //fallthrough
case "jpg":
t = new Texture();
Stream stream = new MemoryStream(texData.CompressedData, false);
t.loadFromStream(stream);
break;
case "dds":
Warn.print("DDS files not supported yet");
break;
default:
Warn.print("Unkown compressed file format {0}", texData.CompressedFormatHint);
break;
}
}
else
{
byte[] bytes = new byte[texData.Width * texData.Height * 4];
for (int i = 0; i < texData.Height; i++)
{
for (int j = 0; i < texData.Width; i++)
{
bytes[j + (i * texData.Width) + 0] = texData.NonCompressedData[j + (i * texData.Width)].R;
bytes[j + (i * texData.Width) + 1] = texData.NonCompressedData[j + (i * texData.Width)].G;
bytes[j + (i * texData.Width) + 2] = texData.NonCompressedData[j + (i * texData.Width)].B;
bytes[j + (i * texData.Width) + 3] = texData.NonCompressedData[j + (i * texData.Width)].A;
}
}
Texture.PixelData pData = new Texture.PixelData();
pData.data = bytes;
pData.dataType = PixelType.Byte;
pData.pixelFormat = PixelFormat.Rgba;
t = new Texture(texData.Width, texData.Height, PixelInternalFormat.Rgba8, pData, true);
}
}
}
else //just a path name
{
string textureName = filepath.TrimStart('/');
TextureDescriptor td = new TextureDescriptor(Path.Combine(myRootPath, textureName), true);
t = myResourceManager.getResource(td) as Texture;
if (t == null)
{
Warn.print("Failed to load texture {0}", filepath);
}
}
return(t);
}
public SkinnedModel loadFromFile(string filename)
{
Info.print("Loading IQM model {0}", filename);
if (File.Exists(filename) == false)
{
Warn.print("Cannot find file {0}", filename);
return(null);
}
V3N3T2B4W4[] vertexData;
ushort[] triangleIndexes;
IQMHeader myHeader;
byte[] myTexts;
List <String> myComments = new List <String>();
iqmvertexarray[] myVertArrays;
iqmjoint[] myJoints;
iqmpose[] myPoses;
iqmanim[] myAnimataions;
iqmbounds[] myBounds;
iqmmesh[] meshData;
ushort[] myFrameData;
SkinnedModel sm = new SkinnedModel();
System.IO.FileStream stream = null;
System.IO.BinaryReader reader = null;
try
{
// Open the specified file as a stream and create a reader
stream = new System.IO.FileStream(filename, FileMode.Open, FileAccess.Read);
reader = new System.IO.BinaryReader(stream);
myHeader.magic = reader.ReadChars(16);
myHeader.version = reader.ReadUInt32();
if (myHeader.version != 2)
{
return(null);
}
myHeader.filesize = reader.ReadUInt32();
myHeader.flags = reader.ReadUInt32();
myHeader.num_text = reader.ReadUInt32();
myHeader.ofs_text = reader.ReadUInt32();
myHeader.num_meshes = reader.ReadUInt32();
myHeader.ofs_meshes = reader.ReadUInt32();
myHeader.num_vertexarrays = reader.ReadUInt32();
myHeader.num_vertexes = reader.ReadUInt32();
myHeader.ofs_vertexarrays = reader.ReadUInt32();
myHeader.num_triangles = reader.ReadUInt32();
myHeader.ofs_triangles = reader.ReadUInt32();
myHeader.ofs_adjacency = reader.ReadUInt32();
myHeader.num_joints = reader.ReadUInt32();
myHeader.ofs_joints = reader.ReadUInt32();
myHeader.num_poses = reader.ReadUInt32();
myHeader.ofs_poses = reader.ReadUInt32();
myHeader.num_anims = reader.ReadUInt32();
myHeader.ofs_anims = reader.ReadUInt32();
myHeader.num_frames = reader.ReadUInt32();
myHeader.num_framechannels = reader.ReadUInt32();
myHeader.ofs_frames = reader.ReadUInt32();
myHeader.ofs_bounds = reader.ReadUInt32();
myHeader.num_comment = reader.ReadUInt32();
myHeader.ofs_comment = reader.ReadUInt32();
myHeader.num_extensions = reader.ReadUInt32();
myHeader.ofs_extensions = reader.ReadUInt32();
boneCount = (int)myHeader.num_joints;
//read text
myTexts = new byte[myHeader.num_text];
stream.Seek(myHeader.ofs_text, SeekOrigin.Begin);
for (int i = 0; i < myHeader.num_text; i++)
{
myTexts[i] = reader.ReadByte();
}
#region read geometry
//create geometry fields
for (int m = 0; m < myHeader.num_meshes; m++)
{
sm.myMeshes.Add(new Mesh());
}
//read the mesh data
meshData = new iqmmesh[myHeader.num_meshes];
stream.Seek(myHeader.ofs_meshes, SeekOrigin.Begin);
for (int i = 0; i < myHeader.num_meshes; i++)
{
iqmmesh temp = new iqmmesh();
UInt32 n = reader.ReadUInt32();
temp.name = readNullTerminated(myTexts, n);
n = reader.ReadUInt32();
temp.material = readNullTerminated(myTexts, n);
String fn = System.IO.Path.GetFileName(temp.material);
fn = System.IO.Path.ChangeExtension(fn, ".png");
String dir = System.IO.Path.GetDirectoryName(filename);
fn = System.IO.Path.Combine(dir, fn);
TextureDescriptor td = new TextureDescriptor(fn);
Texture tex = myResourceManager.getResource(td) as Texture;
Material m = new Material(temp.material);
m.addAttribute(new TextureAttribute("diffuseMap", tex));
m.myFeatures |= Material.Feature.Lighting;
m.myFeatures |= Material.Feature.DiffuseMap;
sm.myMeshes[i].material = m;
temp.first_vertex = reader.ReadUInt32();
temp.num_vertexes = reader.ReadUInt32();
temp.first_triangle = reader.ReadUInt32();
temp.num_triangles = reader.ReadUInt32();
meshData[i] = temp;
}
//read vertex arrays
myVertArrays = new iqmvertexarray[myHeader.num_vertexarrays];
stream.Seek(myHeader.ofs_vertexarrays, SeekOrigin.Begin);
for (int i = 0; i < myHeader.num_vertexarrays; i++)
{
iqmvertexarray temp = new iqmvertexarray();
temp.type = (VertexArrayType)reader.ReadUInt32();
temp.flags = reader.ReadUInt32();
temp.format = (VertexArrayFormat)reader.ReadUInt32();
temp.size = reader.ReadUInt32();
temp.offset = reader.ReadUInt32();
myVertArrays[i] = temp;
}
//read the vertex data
vertexData = new V3N3T2B4W4[myHeader.num_vertexes];
for (int i = 0; i < myHeader.num_vertexarrays; i++)
{
iqmvertexarray va = myVertArrays[i];
switch (va.type)
{
case VertexArrayType.IQM_POSITION:
{
stream.Seek(va.offset, SeekOrigin.Begin);
for (int j = 0; j < myHeader.num_vertexes; j++)
{
Vector3 temp = new Vector3();
temp.X = reader.ReadSingle();
temp.Y = reader.ReadSingle();
temp.Z = reader.ReadSingle();
vertexData[j].Position = temp;
}
break;
}
case VertexArrayType.IQM_TEXCOORD:
{
stream.Seek(va.offset, SeekOrigin.Begin);
for (int j = 0; j < myHeader.num_vertexes; j++)
{
Vector2 temp = new Vector2();
temp.X = reader.ReadSingle();
temp.Y = reader.ReadSingle();
vertexData[j].TexCoord = temp;
}
break;
}
case VertexArrayType.IQM_NORMAL:
{
stream.Seek(va.offset, SeekOrigin.Begin);
for (int j = 0; j < myHeader.num_vertexes; j++)
{
Vector3 temp = new Vector3();
temp.X = reader.ReadSingle();
temp.Y = reader.ReadSingle();
temp.Z = reader.ReadSingle();
vertexData[j].Normal = temp;
}
break;
}
case VertexArrayType.IQM_BLENDINDEXES:
{
stream.Seek(va.offset, SeekOrigin.Begin);
for (int j = 0; j < myHeader.num_vertexes; j++)
{
Vector4 temp = new Vector4();
temp.X = (float)reader.ReadByte();
temp.Y = (float)reader.ReadByte();
temp.Z = (float)reader.ReadByte();
temp.W = (float)reader.ReadByte();
vertexData[j].BoneId = temp;
}
break;
}
case VertexArrayType.IQM_BLENDWEIGHTS:
{
stream.Seek(va.offset, SeekOrigin.Begin);
for (int j = 0; j < myHeader.num_vertexes; j++)
{
Vector4 temp = new Vector4();
temp.X = ((float)reader.ReadByte()) / 255.0f;
temp.Y = ((float)reader.ReadByte()) / 255.0f;
temp.Z = ((float)reader.ReadByte()) / 255.0f;
temp.W = ((float)reader.ReadByte()) / 255.0f;
vertexData[j].BoneWeight = temp;
}
break;
}
}
}
//read triangles indexes
triangleIndexes = new ushort[myHeader.num_triangles * 3];
stream.Seek(myHeader.ofs_triangles, SeekOrigin.Begin);
for (int i = 0; i < myHeader.num_triangles * 3; i++)
{
triangleIndexes[i] = (ushort)reader.ReadUInt32();
}
#endregion
#region read animation data
//read joints
myJoints = new iqmjoint[myHeader.num_joints];
stream.Seek(myHeader.ofs_joints, SeekOrigin.Begin);
for (int i = 0; i < myHeader.num_joints; i++)
{
iqmjoint temp = new iqmjoint();
UInt32 n = reader.ReadUInt32();
temp.name = readNullTerminated(myTexts, n);
temp.parent = reader.ReadInt32();
temp.translate = new Vector3();
temp.translate.X = reader.ReadSingle();
temp.translate.Y = reader.ReadSingle();
temp.translate.Z = reader.ReadSingle();
temp.rotate = new Quaternion();
temp.rotate.X = reader.ReadSingle();
temp.rotate.Y = reader.ReadSingle();
temp.rotate.Z = reader.ReadSingle();
temp.rotate.W = reader.ReadSingle();
temp.rotate.Normalize();
temp.scale = new Vector3();
temp.scale.X = reader.ReadSingle();
temp.scale.Y = reader.ReadSingle();
temp.scale.Z = reader.ReadSingle();
myJoints[i] = temp;
}
//read poses
myPoses = new iqmpose[myHeader.num_poses];
stream.Seek(myHeader.ofs_poses, SeekOrigin.Begin);
for (int i = 0; i < myHeader.num_poses; i++)
{
iqmpose temp = new iqmpose();
temp.parent = reader.ReadInt32();
temp.channelmask = reader.ReadUInt32();
temp.channeloffset = new float[10];
for (int j = 0; j < 10; j++)
{
temp.channeloffset[j] = reader.ReadSingle();
}
temp.channelscale = new float[10];
for (int j = 0; j < 10; j++)
{
temp.channelscale[j] = reader.ReadSingle();
}
myPoses[i] = temp;
}
//read animations
myAnimataions = new iqmanim[myHeader.num_anims];
stream.Seek(myHeader.ofs_anims, SeekOrigin.Begin);
for (int i = 0; i < myHeader.num_anims; i++)
{
iqmanim temp = new iqmanim();
UInt32 n = reader.ReadUInt32();
temp.name = readNullTerminated(myTexts, n);
temp.first_frame = reader.ReadUInt32();
temp.num_frames = reader.ReadUInt32();
temp.framerate = reader.ReadSingle();
temp.flags = reader.ReadUInt32();
myAnimataions[i] = temp;
Animation a = new Animation();
a.name = temp.name;
a.fps = temp.framerate;
a.loop = true;
sm.animations.Add(a.name, a);
}
//read frame data
myFrameData = new ushort[myHeader.num_frames * myHeader.num_framechannels];
stream.Seek(myHeader.ofs_frames, SeekOrigin.Begin);
for (int i = 0; i < myHeader.num_frames * myHeader.num_framechannels; i++)
{
myFrameData[i] = reader.ReadUInt16();
}
#endregion
//read bounds
myBounds = new iqmbounds[myHeader.num_frames];
stream.Seek(myHeader.ofs_bounds, SeekOrigin.Begin);
for (int i = 0; i < myHeader.num_frames; i++)
{
iqmbounds temp = new iqmbounds();
temp.bbmins = new float[3];
temp.bbmaxs = new float[3];
temp.bbmins[0] = reader.ReadSingle();
temp.bbmins[1] = reader.ReadSingle();
temp.bbmins[2] = reader.ReadSingle();
temp.bbmaxs[0] = reader.ReadSingle();
temp.bbmaxs[1] = reader.ReadSingle();
temp.bbmaxs[2] = reader.ReadSingle();
temp.xyradius = reader.ReadSingle();
temp.radius = reader.ReadSingle();
if (i == 0)
{
sm.size = temp.radius;
}
}
//read comments
stream.Seek(myHeader.ofs_comment, SeekOrigin.Begin);
int charRead = 0;
while (charRead < myHeader.num_comment)
{
char c = reader.ReadChar(); charRead++;
string s = "";
while (c != '\0')
{
s += c;
c = reader.ReadChar(); charRead++;
}
myComments.Add(s);
}
//read extensions
//TODO
//setup the bone data
Matrix4[] baseframe = new Matrix4[myHeader.num_joints];
Matrix4[] inversebaseframe = new Matrix4[myHeader.num_joints];
for (int i = 0; i < (int)myHeader.num_joints; i++)
{
iqmjoint joint = myJoints[i];
Matrix4 r, t, s;
r = Matrix4.CreateFromQuaternion(joint.rotate);
t = Matrix4.CreateTranslation(joint.translate);
s = Matrix4.CreateScale(joint.scale);
baseframe[i] = s * r * t;
inversebaseframe[i] = baseframe[i].Inverted();
if (joint.parent >= 0)
{
baseframe[i] = baseframe[i] * baseframe[joint.parent];
inversebaseframe[i] = inversebaseframe[joint.parent] * inversebaseframe[i];
}
Bone b = new Bone();
b.myName = myJoints[i].name;
b.myParent = myJoints[i].parent;
b.myWorldBindMatrix = baseframe[i];
sm.skeleton.myBones.Add(b);
}
Matrix4[] absMatrix = new Matrix4[myHeader.num_frames * myHeader.num_poses];
int count = 0;
for (int i = 0; i < myHeader.num_frames; i++)
{
for (int j = 0; j < myHeader.num_poses; j++)
{
iqmpose p = myPoses[j];
Quaternion rotate = new Quaternion();
Vector3 translate = new Vector3();
Vector3 scale = new Vector3();
translate.X = p.channeloffset[0]; if ((p.channelmask & 0x01) != 0)
{
translate.X += myFrameData[count++] * p.channelscale[0];
}
translate.Y = p.channeloffset[1]; if ((p.channelmask & 0x02) != 0)
{
translate.Y += myFrameData[count++] * p.channelscale[1];
}
translate.Z = p.channeloffset[2]; if ((p.channelmask & 0x04) != 0)
{
translate.Z += myFrameData[count++] * p.channelscale[2];
}
rotate.X = p.channeloffset[3]; if ((p.channelmask & 0x08) != 0)
{
rotate.X += myFrameData[count++] * p.channelscale[3];
}
rotate.Y = p.channeloffset[4]; if ((p.channelmask & 0x10) != 0)
{
rotate.Y += myFrameData[count++] * p.channelscale[4];
}
rotate.Z = p.channeloffset[5]; if ((p.channelmask & 0x20) != 0)
{
rotate.Z += myFrameData[count++] * p.channelscale[5];
}
rotate.W = p.channeloffset[6]; if ((p.channelmask & 0x40) != 0)
{
rotate.W += myFrameData[count++] * p.channelscale[6];
}
scale.X = p.channeloffset[7]; if ((p.channelmask & 0x80) != 0)
{
scale.X += myFrameData[count++] * p.channelscale[7];
}
scale.Y = p.channeloffset[8]; if ((p.channelmask & 0x100) != 0)
{
scale.Y += myFrameData[count++] * p.channelscale[8];
}
scale.Z = p.channeloffset[9]; if ((p.channelmask & 0x200) != 0)
{
scale.Z += myFrameData[count++] * p.channelscale[9];
}
// Concatenate each pose with the inverse base pose to avoid doing this at animation time.
// If the joint has a parent, then it needs to be pre-concatenated with its parent's base pose.
// Thus it all negates at animation time like so:
// (parentPose * parentInverseBasePose) * (parentBasePose * childPose * childInverseBasePose) =>
// parentPose * (parentInverseBasePose * parentBasePose) * childPose * childInverseBasePose =>
// parentPose * childPose * childInverseBasePose
rotate.Normalize();
Matrix4 r, t, s;
r = Matrix4.CreateFromQuaternion(rotate);
t = Matrix4.CreateTranslation(translate);
s = Matrix4.CreateScale(scale);
Matrix4 pose = s * r * t;
if (p.parent >= 0)
{
Matrix4 parent = baseframe[p.parent];
Matrix4 inv = inversebaseframe[j];
Matrix4 parentPose = absMatrix[i * myHeader.num_poses + p.parent];
absMatrix[i * myHeader.num_poses + j] = inv * pose * parent * parentPose;
}
else
{
Matrix4 inv = inversebaseframe[j];
absMatrix[i * myHeader.num_poses + j] = inv * pose;
}
}
}
Vector4[] boneData = new Vector4[myHeader.num_frames * myHeader.num_poses * 4];
int next = 0;
for (int i = 0; i < myHeader.num_frames * myHeader.num_poses; i++)
{
boneData[next++] = absMatrix[i].Row0;
boneData[next++] = absMatrix[i].Row1;
boneData[next++] = absMatrix[i].Row2;
boneData[next++] = absMatrix[i].Row3;
}
//setup the buffers
sm.myBindings = V3N3T2B4W4.bindings();
VertexBufferObject vbo = new VertexBufferObject(BufferUsageHint.StaticDraw);
vbo.setData(vertexData);
sm.myVbos.Add(vbo);
List <ushort> indexes = new List <ushort>();
int indexCount = 0;
for (int m = 0; m < sm.myMeshes.Count; m++)
{
Mesh mesh = sm.myMeshes[m];
mesh.primativeType = PrimitiveType.Triangles;
mesh.indexBase = indexCount;
for (int t = 0; t < meshData[m].num_triangles; t++)
{
//swap the order the indicies since we want counter clockwise triangles instead of clockwise
indexes.Add(triangleIndexes[meshData[m].first_triangle * 3 + (t * 3) + 0]);
indexes.Add(triangleIndexes[meshData[m].first_triangle * 3 + (t * 3) + 2]);
indexes.Add(triangleIndexes[meshData[m].first_triangle * 3 + (t * 3) + 1]);
indexCount += 3;
}
mesh.indexCount = indexCount - mesh.indexBase;
}
sm.myIbo.setData(indexes);
//upload the frame data
sm.myFrames.setData(boneData);
return(sm);
}
catch (Exception ex)
{
throw new Exception("Error while loading IQM model from definition file ( " + filename + " ).", ex);
}
finally
{
if (reader != null)
{
reader.Close();
}
if (stream != null)
{
stream.Close();
stream.Dispose();
}
}
}
public bool buildFont()
{
TextureDescriptor td = new TextureDescriptor(myFilename + ".png", false);
texture = Renderer.resourceManager.getResource(td) as Texture;
FileInfo file = new FileInfo(myFilename + ".txt");
StreamReader reader = file.OpenText();
string line;
while ((line = reader.ReadLine()) != null)
{
String[] splitters = { " " };
String[] tokens = line.Split(splitters, StringSplitOptions.RemoveEmptyEntries);
if (tokens[0] == "info")
{
}
if (tokens[0] == "chars")
{
}
if (tokens[0] == "char")
{
String[] split;
//id
split = tokens[1].Split('=');
int id = Convert.ToInt32(split[1]);
//X and Y are in pixels, so need to be converted to S/T coordinates (normalized)
//x
split = tokens[2].Split('=');
myGlyphs[id].minTexCoord.X = Convert.ToSingle(split[1]) / texture.width;
//y
split = tokens[3].Split('=');
myGlyphs[id].minTexCoord.Y = Convert.ToSingle(split[1]) / texture.height;
//width and height are in pixels, need to convert to S/T coordinates
//width
split = tokens[4].Split('=');
myGlyphs[id].maxTexCoord.X = myGlyphs[id].minTexCoord.X;
myGlyphs[id].maxTexCoord.X += Convert.ToSingle(split[1]) / texture.width;
myGlyphs[id].size.X = Convert.ToSingle(split[1]);
//height
split = tokens[5].Split('=');
myGlyphs[id].maxTexCoord.Y = myGlyphs[id].minTexCoord.Y;
myGlyphs[id].maxTexCoord.Y += Convert.ToSingle(split[1]) / texture.height;
myGlyphs[id].size.Y = Convert.ToSingle(split[1]);
//xoffset
split = tokens[6].Split('=');
myGlyphs[id].offset.X = Convert.ToSingle(split[1]);
//yoffset
split = tokens[7].Split('=');
myGlyphs[id].offset.Y = Convert.ToSingle(split[1]);
//xadvance
split = tokens[8].Split('=');
myGlyphs[id].advance.X = Convert.ToSingle(split[1]);
}
}
return(true);
}
public bool loadMaterialFromFile(string path)
{
string rootPath = Path.GetDirectoryName(path);
string filename = Path.GetFileNameWithoutExtension(path);
filename += ".mtl";
filename = Path.Combine(rootPath, filename);
if (File.Exists(filename) == false)
{
Warn.print("Cannot find file {0}", filename);
return(false);
}
StreamReader file = new StreamReader(filename);
String line;
while ((line = file.ReadLine()) != null)
{
line = line.Trim();
line = line.ToLowerInvariant();
String[] tokens = line.Split(' ');
switch (tokens[0])
{
case "#":
{
continue;
}
case "newmtl":
{
Material m = new Material(tokens[1]);
m.myFeatures |= Material.Feature.Lighting;
while (line != "" && line != null)
{
line = line.Trim();
String[] matTokens = line.Split(' ');
matTokens[0] = matTokens[0].ToLowerInvariant();
switch (matTokens[0])
{
case "ka":
{
Color4 c = new Color4();
c.R = System.Convert.ToSingle(matTokens[1]);
c.G = System.Convert.ToSingle(matTokens[2]);
c.B = System.Convert.ToSingle(matTokens[3]);
m.ambient = c;
break;
}
case "kd":
{
Color4 c = new Color4();
c.R = System.Convert.ToSingle(matTokens[1]);
c.G = System.Convert.ToSingle(matTokens[2]);
c.B = System.Convert.ToSingle(matTokens[3]);
m.diffuse = c;
break;
}
case "ks":
{
Color4 c = new Color4();
c.R = System.Convert.ToSingle(matTokens[1]);
c.G = System.Convert.ToSingle(matTokens[2]);
c.B = System.Convert.ToSingle(matTokens[3]);
m.spec = c;
break;
}
case "ns":
{
float val = System.Convert.ToSingle(matTokens[1]);
m.shininess = val;
break;
}
case "d":
{
float val = System.Convert.ToSingle(matTokens[1]);
m.alpha = val;
break;
}
case "map_ka":
{
string textureName = matTokens[1];
TextureDescriptor td = new TextureDescriptor(Path.Combine(rootPath, textureName), true);
Texture t = myResourceManager.getResource(td) as Texture;
if (t != null)
{
m.addAttribute(new TextureAttribute("ambientMap", t));
}
break;
}
case "map_kd":
{
string textureName = matTokens[1];
TextureDescriptor td = new TextureDescriptor(Path.Combine(rootPath, textureName), true);
Texture t = myResourceManager.getResource(td) as Texture;
if (t != null)
{
m.addAttribute(new TextureAttribute("diffuseMap", t));
m.myFeatures |= Material.Feature.DiffuseMap;
m.hasTransparency = t.hasAlpha;
}
break;
}
case "map_ks":
{
string textureName = matTokens[1];
TextureDescriptor td = new TextureDescriptor(Path.Combine(rootPath, textureName), true);
Texture t = myResourceManager.getResource(td) as Texture;
if (t != null)
{
m.addAttribute(new TextureAttribute("specularMap", t));
m.myFeatures |= Material.Feature.SpecMap;
}
break;
}
case "map_d":
{
string textureName = matTokens[1];
TextureDescriptor td = new TextureDescriptor(Path.Combine(rootPath, textureName), true);
Texture t = myResourceManager.getResource(td) as Texture;
if (t != null)
{
m.addAttribute(new TextureAttribute("alphaMap", t));
}
break;
}
case "bump":
case "map_bump":
{
string textureName = matTokens[1];
TextureDescriptor td = new TextureDescriptor(Path.Combine(rootPath, textureName), true);
Texture t = myResourceManager.getResource(td) as Texture;
if (t != null)
{
m.addAttribute(new TextureAttribute("normalMap", t));
m.myFeatures |= Material.Feature.NormalMap;
}
break;
}
case "disp":
{
string textureName = matTokens[1];
TextureDescriptor td = new TextureDescriptor(Path.Combine(rootPath, textureName), true);
Texture t = myResourceManager.getResource(td) as Texture;
if (t != null)
{
m.addAttribute(new TextureAttribute("displaceMap", t));
m.myFeatures |= Material.Feature.DisplacementMap;
}
break;
}
}
line = file.ReadLine();
}
myMaterials.Add(tokens[1], m);
}
break;
}
}
file.Close();
return(true);
}
