/// <summary>
///
/// </summary>
/// <param name="lexer"></param>
/// <returns>A register index.</returns>
private int ParseTerm(idLexer lexer)
{
idToken token = lexer.ReadToken();
string tokenValue = token.ToString();
string tokenLower = tokenValue.ToLower();
if(tokenValue == "(")
{
int a = ParseExpression(lexer);
MatchToken(lexer, ")");
return a;
}
ExpressionRegister tmpReg;
if(Enum.TryParse<ExpressionRegister>(tokenValue, true, out tmpReg) == true)
{
_parsingData.RegistersAreConstant = false;
return (int) tmpReg;
}
if(tokenLower == "fragmentPrograms")
{
return GetExpressionConstant(1.0f);
}
else if(tokenLower == "sound")
{
_parsingData.RegistersAreConstant = false;
return EmitOp(0, 0, ExpressionOperationType.Sound);
}
// parse negative numbers
else if(tokenLower == "-")
{
token = lexer.ReadToken();
if((token.Type == TokenType.Number) || (token.ToString() == "."))
{
return GetExpressionConstant(-token.ToFloat());
}
lexer.Warning("Bad negative number '{0}'", token.ToString());
this.MaterialFlag = MaterialFlags.Defaulted;
return 0;
}
else if((token.Type == TokenType.Number) || (tokenValue == ".") || (tokenValue == "-"))
{
return GetExpressionConstant(token.ToFloat());
}
// see if it is a table name
idDeclTable table = idE.DeclManager.FindType<idDeclTable>(DeclType.Table, tokenValue, false);
if(table == null)
{
lexer.Warning("Bad term '{0}'", tokenValue);
this.MaterialFlag = MaterialFlags.Defaulted;
return 0;
}
// parse a table expression
MatchToken(lexer, "[");
int b = ParseExpression(lexer);
MatchToken(lexer, "]");
return EmitOp(table.Index, b, ExpressionOperationType.Table);
}
public override bool Parse(string text)
{
if(this.Disposed == true)
{
throw new ObjectDisposedException(this.GetType().Name);
}
idLexer lexer = new idLexer(idDeclFile.LexerOptions);
lexer.LoadMemory(text, this.FileName, this.LineNumber);
lexer.SkipUntilString("{");
idToken token;
idToken token2;
string value;
while(true)
{
if((token = lexer.ReadToken()) == null)
{
break;
}
value = token.ToString();
if(value == "}")
{
break;
}
if(token.Type != TokenType.String)
{
lexer.Warning("Expected quoted string, but found '{0}'", value);
MakeDefault();
return false;
}
if((token2 = lexer.ReadToken()) == null)
{
lexer.Warning("Unexpected end of file");
MakeDefault();
return false;
}
if(_dict.ContainsKey(value) == true)
{
lexer.Warning("'{0}' already defined", value);
}
_dict.Set(value, token2.ToString());
}
// we always automatically set a "classname" key to our name
_dict.Set("classname", this.Name);
// "inherit" keys will cause all values from another entityDef to be copied into this one
// if they don't conflict. We can't have circular recursions, because each entityDef will
// never be parsed more than once
// find all of the dicts first, because copying inherited values will modify the dict
List<idDeclEntity> defList = new List<idDeclEntity>();
List<string> keysToRemove = new List<string>();
foreach(KeyValuePair<string, string> kvp in _dict.MatchPrefix("inherit"))
{
idDeclEntity copy = idE.DeclManager.FindType<idDeclEntity>(DeclType.EntityDef, kvp.Value, false);
if(copy == null)
{
lexer.Warning("Unknown entityDef '{0}' inherited by '{1}'", kvp.Value, this.Name);
}
else
{
defList.Add(copy);
}
// delete this key/value pair
keysToRemove.Add(kvp.Key);
}
_dict.Remove(keysToRemove.ToArray());
// now copy over the inherited key / value pairs
foreach(idDeclEntity def in defList)
{
_dict.SetDefaults(def._dict);
}
// precache all referenced media
// do this as long as we arent in modview
idE.Game.CacheDictionaryMedia(_dict);
return true;
}
private void ParseSort(idLexer lexer)
{
idToken token = lexer.ReadTokenOnLine();
if(token == null)
{
lexer.Warning("missing sort parameter");
this.MaterialFlag = MaterialFlags.Defaulted;
return;
}
try
{
_sort = (int) Enum.Parse(typeof(MaterialSort), token.ToString(), true);
}
catch(Exception)
{
float.TryParse(token.ToString(), out _sort);
}
}
private void ParseDeform(idLexer lexer)
{
idToken token = lexer.ExpectAnyToken();
if(token == null)
{
return;
}
string tokenValue = token.ToString();
string tokenLower = tokenValue.ToLower();
if(tokenLower == "sprite")
{
_deformType = DeformType.Sprite;
_cullType = CullType.TwoSided;
this.MaterialFlag = MaterialFlags.NoShadows;
}
else if(tokenLower == "tube")
{
_deformType = DeformType.Tube;
_cullType = CullType.TwoSided;
this.MaterialFlag = MaterialFlags.NoShadows;
}
else if(tokenLower == "flare")
{
_deformType = DeformType.Flare;
_cullType = CullType.TwoSided;
_deformRegisters[0] = ParseExpression(lexer);
this.MaterialFlag = MaterialFlags.NoShadows;
}
else if(tokenLower == "expand")
{
_deformType = DeformType.Expand;
_deformRegisters[0] = ParseExpression(lexer);
}
else if(tokenLower == "move")
{
_deformType = DeformType.Move;
_deformRegisters[0] = ParseExpression(lexer);
}
else if(tokenLower == "turbulent")
{
_deformType = DeformType.Turbulent;
if((token = lexer.ExpectAnyToken()) == null)
{
lexer.Warning("deform particle missing particle name");
this.MaterialFlag = MaterialFlags.Defaulted;
}
else
{
_deformDecl = idE.DeclManager.FindType(DeclType.Table, token.ToString(), true);
_deformRegisters[0] = ParseExpression(lexer);
_deformRegisters[1] = ParseExpression(lexer);
_deformRegisters[2] = ParseExpression(lexer);
}
}
else if(tokenLower == "eyeball")
{
_deformType = DeformType.Eyeball;
}
else if(tokenLower == "particle")
{
_deformType = DeformType.Particle;
if((token = lexer.ExpectAnyToken()) == null)
{
lexer.Warning("deform particle missing particle name");
this.MaterialFlag = MaterialFlags.Defaulted;
}
else
{
_deformDecl = idE.DeclManager.FindType(DeclType.Particle, token.ToString(), true);
}
}
else if(tokenLower == "particle2")
{
_deformType = DeformType.Particle2;
if((token = lexer.ExpectAnyToken()) == null)
{
lexer.Warning("deform particle missing particle name");
this.MaterialFlag = MaterialFlags.Defaulted;
}
else
{
_deformDecl = idE.DeclManager.FindType(DeclType.Table, token.ToString(), true);
_deformRegisters[0] = ParseExpression(lexer);
_deformRegisters[1] = ParseExpression(lexer);
_deformRegisters[2] = ParseExpression(lexer);
}
}
else
{
lexer.Warning("Bad deform type '{0}'", tokenValue);
this.MaterialFlag = MaterialFlags.Defaulted;
}
}
public void Parse(idLexer lexer, idJointMatrix[] joints)
{
lexer.ExpectTokenString("{");
//
// parse name
//
if(lexer.CheckTokenString("name") == true)
{
lexer.ReadToken();
}
//
// parse shader
//
lexer.ExpectTokenString("shader");
idToken token = lexer.ReadToken();
string materialName = token.ToString();
_material = idE.DeclManager.FindMaterial(materialName);
//
// parse texture coordinates
//
lexer.ExpectTokenString("numverts");
int count = lexer.ParseInt();
if(count < 0)
{
lexer.Error("Invalid size: {0}", token.ToString());
}
_texCoords = new Vector2[count];
int[] firstWeightForVertex = new int[count];
int[] weightCountForVertex = new int[count];
int maxWeight = 0;
int coordCount = _texCoords.Length;
_weightCount = 0;
for(int i = 0; i < coordCount; i++)
{
lexer.ExpectTokenString("vert");
lexer.ParseInt();
float[] tmp = lexer.Parse1DMatrix(2);
_texCoords[i] = new Vector2(tmp[0], tmp[1]);
firstWeightForVertex[i] = lexer.ParseInt();
weightCountForVertex[i] = lexer.ParseInt();
if(weightCountForVertex[i] == 0)
{
lexer.Error("Vertex without any joint weights.");
}
_weightCount += weightCountForVertex[i];
if((weightCountForVertex[i] + firstWeightForVertex[i]) > maxWeight)
{
maxWeight = weightCountForVertex[i] + firstWeightForVertex[i];
}
}
//
// parse tris
//
lexer.ExpectTokenString("numtris");
_triangleCount = lexer.ParseInt();
if(_triangleCount < 0)
{
lexer.Error("Invalid size: {0}", _triangleCount);
}
int[] tris = new int[_triangleCount * 3];
for(int i = 0; i < _triangleCount; i++)
{
lexer.ExpectTokenString("tri");
lexer.ParseInt();
tris[i * 3 + 0] = lexer.ParseInt();
tris[i * 3 + 1] = lexer.ParseInt();
tris[i * 3 + 2] = lexer.ParseInt();
}
//
// parse weights
//
lexer.ExpectTokenString("numweights");
count = lexer.ParseInt();
if(count < 0)
{
lexer.Error("Invalid size: {0}", count);
}
if(maxWeight > count)
{
lexer.Warning("Vertices reference out of range weights in model ({0} of {1} weights).", maxWeight, count);
}
VertexWeight[] tempWeights = new VertexWeight[count];
for(int i = 0; i < count; i++)
{
lexer.ExpectTokenString("weight");
lexer.ParseInt();
int jointIndex = lexer.ParseInt();
if((jointIndex < 0) || (jointIndex >= joints.Length))
{
lexer.Error("Joint index out of range({0}): {1}", joints.Length, jointIndex);
}
tempWeights[i].JointIndex = jointIndex;
tempWeights[i].JointWeight = lexer.ParseFloat();
float[] tmp = lexer.Parse1DMatrix(3);
tempWeights[i].Offset = new Vector3(tmp[0], tmp[1], tmp[2]);
}
// create pre-scaled weights and an index for the vertex/joint lookup
_scaledWeights = new Vector4[_weightCount];
_weightIndex = new int[_weightCount * 2];
count = 0;
coordCount = _texCoords.Length;
for(int i = 0; i < coordCount; i++)
{
int num = firstWeightForVertex[i];
int weightCount = weightCountForVertex[i];
for(int j = 0; j < weightCount; j++, num++, count++)
{
Vector3 tmp = tempWeights[num].Offset * tempWeights[num].JointWeight;
_scaledWeights[count].X = tmp.X;
_scaledWeights[count].Y = tmp.Y;
_scaledWeights[count].Z = tmp.Z;
_scaledWeights[count].W = tempWeights[num].JointWeight;
_weightIndex[count * 2 + 0] = tempWeights[num].JointIndex;
}
_weightIndex[count * 2 - 1] = 1;
}
lexer.ExpectTokenString("}");
// update counters
idConsole.Warning("TODO: idRenderModel_MD5 update counters");
/*c_numVerts += texCoords.Num();
c_numWeights += numWeights;
c_numWeightJoints++;
for ( i = 0; i < numWeights; i++ ) {
c_numWeightJoints += weightIndex[i*2+1];
}*/
//
// build the information that will be common to all animations of this mesh:
// silhouette edge connectivity and normal / tangent generation information
//
Vertex[] verts = new Vertex[_texCoords.Length];
int vertCount = verts.Length;
for(int i = 0; i < vertCount; i++)
{
verts[i].TextureCoordinates = _texCoords[i];
}
TransformVertices(verts, joints);
idConsole.Warning("TODO: idMD5Mesh Deform");
//_deformInfo = idE.RenderSystem.BuildDeformInformation(verts, tris, _material.UseUnsmoothedTangents);
}
/// <summary>
/// This is used during both the initial load, and any reloads.
/// </summary>
/// <returns></returns>
public int LoadAndParse()
{
// load the text
idConsole.DeveloperWriteLine("...loading '{0}'", this.FileName);
byte[] data = idE.FileSystem.ReadFile(this.FileName);
if(data == null)
{
idConsole.FatalError("couldn't load {0}", this.FileName);
return 0;
}
string content = UTF8Encoding.UTF8.GetString(data);
idLexer lexer = new idLexer();
lexer.Options = LexerOptions;
if(lexer.LoadMemory(content, this.FileName) == false)
{
idConsole.Error("Couldn't parse {0}", this.FileName);
return 0;
}
// mark all the defs that were from the last reload of this file
foreach(idDecl decl in _decls)
{
decl.RedefinedInReload = false;
}
// TODO: checksum = MD5_BlockChecksum( buffer, length );
_fileSize = content.Length;
int startMarker, sourceLine;
int size;
string name;
bool reparse;
idToken token;
idDecl newDecl;
DeclType identifiedType;
string tokenValue;
// scan through, identifying each individual declaration
while(true)
{
startMarker = lexer.FileOffset;
sourceLine = lexer.LineNumber;
// parse the decl type name
if((token = lexer.ReadToken()) == null)
{
break;
}
tokenValue = token.ToString();
// get the decl type from the type name
identifiedType = idE.DeclManager.GetDeclTypeFromName(tokenValue);
if(identifiedType == DeclType.Unknown)
{
if(tokenValue == "{")
{
// if we ever see an open brace, we somehow missed the [type] <name> prefix
lexer.Warning("Missing decl name");
lexer.SkipBracedSection(false);
continue;
}
else
{
if(this.DefaultType == DeclType.Unknown)
{
lexer.Warning("No type");
continue;
}
lexer.UnreadToken = token;
// use the default type
identifiedType = this.DefaultType;
}
}
// now parse the name
if((token = lexer.ReadToken()) == null)
{
lexer.Warning("Type without definition at the end of file");
break;
}
tokenValue = token.ToString();
if(tokenValue == "{")
{
// if we ever see an open brace, we somehow missed the [type] <name> prefix
lexer.Warning("Missing decl name");
lexer.SkipBracedSection(false);
continue;
}
// FIXME: export decls are only used by the model exporter, they are skipped here for now
if(identifiedType == DeclType.ModelExport)
{
lexer.SkipBracedSection();
continue;
}
name = tokenValue;
// make sure there's a '{'
if((token = lexer.ReadToken()) == null)
{
lexer.Warning("Type without definition at end of file");
break;
}
tokenValue = token.ToString();
if(tokenValue != "{")
{
lexer.Warning("Expecting '{{' but found '{0}'", tokenValue);
continue;
}
lexer.UnreadToken = token;
// now take everything until a matched closing brace
lexer.SkipBracedSection();
size = lexer.FileOffset - startMarker;
// look it up, possibly getting a newly created default decl
reparse = false;
newDecl = idE.DeclManager.FindTypeWithoutParsing(identifiedType, name, false);
if(newDecl != null)
{
// update the existing copy
if((newDecl.SourceFile != this) || (newDecl.RedefinedInReload == true))
{
lexer.Warning("{0} '{1}' previously defined at {2}:{3}", identifiedType.ToString().ToLower(), name, newDecl.FileName, newDecl.LineNumber);
continue;
}
if(newDecl.State != DeclState.Unparsed)
{
reparse = true;
}
}
else
{
// allow it to be created as a default, then add it to the per-file list
newDecl = idE.DeclManager.FindTypeWithoutParsing(identifiedType, name, true);
if(newDecl == null)
{
lexer.Warning("could not instanciate decl '{0}' with name '{1}'", identifiedType.ToString().ToLower(), name);
continue;
}
_decls.Add(newDecl);
}
newDecl.RedefinedInReload = true;
newDecl.SourceText = content.Substring(startMarker, size);
newDecl.SourceFile = this;
newDecl.SourceTextOffset = startMarker;
newDecl.SourceTextLength = size;
newDecl.SourceLine = sourceLine;
newDecl.State = DeclState.Unparsed;
// if it is currently in use, reparse it immedaitely
if(reparse)
{
newDecl.ParseLocal();
}
}
_lineCount = lexer.LineNumber;
// any defs that weren't redefinedInReload should now be defaulted
foreach(idDecl decl in _decls)
{
if(decl.RedefinedInReload == false)
{
decl.MakeDefault();
decl.SourceTextOffset = decl.SourceFile.FileSize;
decl.SourceTextLength = 0;
decl.SourceLine = decl.SourceFile.LineCount;
}
}
return _checksum;
}
private bool ParseMaterial(idLexer lexer)
{
_parameters.MinDistance = 1;
_parameters.MaxDistance = 10;
_parameters.Volume = 1;
_speakerMask = 0;
_altSound = null;
idToken token;
string tokenValue;
int sampleCount = 0;
while(true)
{
if((token = lexer.ExpectAnyToken()) == null)
{
return false;
}
tokenValue = token.ToString().ToLower();
if(tokenValue == "}")
{
break;
}
// minimum number of sounds
else if(tokenValue == "minsamples")
{
sampleCount = lexer.ParseInt();
}
else if(tokenValue == "description")
{
_description = lexer.ReadTokenOnLine().ToString();
}
else if(tokenValue == "mindistance")
{
_parameters.MinDistance = lexer.ParseFloat();
}
else if(tokenValue == "maxdistance")
{
_parameters.MaxDistance = lexer.ParseFloat();
}
else if(tokenValue == "shakes")
{
token = lexer.ExpectAnyToken();
if(token.Type == TokenType.Number)
{
_parameters.Shakes = token.ToFloat();
}
else
{
lexer.UnreadToken = token;
_parameters.Shakes = 1.0f;
}
}
else if(tokenValue == "reverb")
{
float reg0 = lexer.ParseFloat();
if(lexer.ExpectTokenString(",") == false)
{
return false;
}
float reg1 = lexer.ParseFloat();
// no longer supported
}
else if(tokenValue == "volume")
{
_parameters.Volume = lexer.ParseFloat();
}
// leadinVolume is used to allow light breaking leadin sounds to be much louder than the broken loop
else if(tokenValue == "leadinvolume")
{
_leadInVolume = lexer.ParseFloat();
}
else if(tokenValue == "mask_center")
{
_speakerMask |= 1 << (int) Speakers.Center;
}
else if(tokenValue == "mask_left")
{
_speakerMask |= 1 << (int) Speakers.Left;
}
else if(tokenValue == "mask_right")
{
_speakerMask |= 1 << (int) Speakers.Right;
}
else if(tokenValue == "mask_backright")
{
_speakerMask |= 1 << (int) Speakers.BackRight;
}
else if(tokenValue == "mask_backleft")
{
_speakerMask |= 1 << (int) Speakers.BackLeft;
}
else if(tokenValue == "mask_lfe")
{
_speakerMask |= 1 << (int) Speakers.Lfe;
}
else if(tokenValue == "soundclass")
{
_parameters.SoundClass = lexer.ParseInt();
if(_parameters.SoundClass < 0)
{
lexer.Warning("SoundClass out of range");
return false;
}
}
else if(tokenValue == "altsound")
{
if((token = lexer.ExpectAnyToken()) == null)
{
return false;
}
_altSound = idE.DeclManager.FindSound(token.ToString());
}
else if(tokenValue == "ordered")
{
// no longer supported
}
else if(tokenValue == "no_dups")
{
_parameters.Flags |= SoundMaterialFlags.NoDuplicates;
}
else if(tokenValue == "no_flicker")
{
_parameters.Flags |= SoundMaterialFlags.NoFlicker;
}
else if(tokenValue == "plain")
{
// no longer supported
}
else if(tokenValue == "looping")
{
_parameters.Flags |= SoundMaterialFlags.Looping;
}
else if(tokenValue == "no_occlusion")
{
_parameters.Flags |= SoundMaterialFlags.NoOcclusion;
}
else if(tokenValue == "private")
{
_parameters.Flags |= SoundMaterialFlags.PrivateSound;
}
else if(tokenValue == "antiprivate")
{
_parameters.Flags |= SoundMaterialFlags.AntiPrivateSound;
}
else if(tokenValue == "playonce")
{
_parameters.Flags |= SoundMaterialFlags.PlayOnce;
}
else if(tokenValue == "global")
{
_parameters.Flags |= SoundMaterialFlags.Global;
}
else if(tokenValue == "unclamped")
{
_parameters.Flags |= SoundMaterialFlags.Unclamped;
}
else if(tokenValue == "omnidirectional")
{
_parameters.Flags |= SoundMaterialFlags.OmniDirectional;
}
// onDemand can't be a parms, because we must track all references and overrides would confuse it
else if(tokenValue == "ondemand")
{
// no longer loading sounds on demand
// _onDemand = true;
}
// the wave files
else if(tokenValue == "leadin")
{
// add to the leadin list
if((token = lexer.ReadToken()) == null)
{
lexer.Warning("Expected sound after leadin");
return false;
}
idConsole.Warning("TODO: leadin");
/*if(soundSystemLocal.soundCache && numLeadins < maxSamples)
{
leadins[numLeadins] = soundSystemLocal.soundCache->FindSound(token.c_str(), onDemand);
numLeadins++;
}*/
}
else if((tokenValue.EndsWith(".wav") == true) || (tokenValue.EndsWith(".ogg") == true))
{
idConsole.Warning("TODO: .wav|.ogg");
/*// add to the wav list
if(soundSystemLocal.soundCache && numEntries < maxSamples)
{
token.BackSlashesToSlashes();
idStr lang = cvarSystem->GetCVarString("sys_lang");
if(lang.Icmp("english") != 0 && token.Find("sound/vo/", false) >= 0)
{
idStr work = token;
work.ToLower();
work.StripLeading("sound/vo/");
work = va("sound/vo/%s/%s", lang.c_str(), work.c_str());
if(fileSystem->ReadFile(work, NULL, NULL) > 0)
{
token = work;
}
else
{
// also try to find it with the .ogg extension
work.SetFileExtension(".ogg");
if(fileSystem->ReadFile(work, NULL, NULL) > 0)
{
token = work;
}
}
}
entries[numEntries] = soundSystemLocal.soundCache->FindSound(token.c_str(), onDemand);
numEntries++;
}*/
}
else
{
lexer.Warning("unknown token '{0}'", token.ToString());
return false;
}
}
if(_parameters.Shakes > 0.0f)
{
idConsole.Warning("TODO: CheckShakesAndOgg()");
}
return true;
}
public override bool Parse(string text)
{
if(this.Disposed == true)
{
throw new ObjectDisposedException(this.GetType().Name);
}
idLexer lexer = new idLexer(idDeclFile.LexerOptions);
lexer.LoadMemory(text, this.FileName, this.LineNumber);
lexer.SkipUntilString("{");
int defaultAnimationCount = 0;
idToken token;
idToken token2;
string tokenValue;
string fileName;
string extension;
int count;
idMD5Joint[] md5Joints;
while(true)
{
if((token = lexer.ReadToken()) == null)
{
break;
}
tokenValue = token.ToString();
if(tokenValue == "}")
{
break;
}
if(tokenValue == "inherit")
{
idConsole.WriteLine("TODO: inherit");
/*if( !src.ReadToken( &token2 ) ) {
src.Warning( "Unexpected end of file" );
MakeDefault();
return false;
}
const idDeclModelDef *copy = static_cast<const idDeclModelDef *>( declManager->FindType( DECL_MODELDEF, token2, false ) );
if ( !copy ) {
common->Warning( "Unknown model definition '%s'", token2.c_str() );
} else if ( copy->GetState() == DS_DEFAULTED ) {
common->Warning( "inherited model definition '%s' defaulted", token2.c_str() );
MakeDefault();
return false;
} else {
CopyDecl( copy );
numDefaultAnims = anims.Num();
}*/
}
else if(tokenValue == "skin")
{
if((token2 = lexer.ReadToken()) == null)
{
lexer.Warning("Unexpected end of file");
MakeDefault();
return false;
}
_skin = idE.DeclManager.FindSkin(token2.ToString());
if(_skin == null)
{
lexer.Warning("Skin '{0}' not found", token2.ToString());
MakeDefault();
return false;
}
}
else if(tokenValue == "mesh")
{
if((token2 = lexer.ReadToken()) == null)
{
lexer.Warning("Unexpected end of file");
MakeDefault();
return false;
}
fileName = token2.ToString();
extension = Path.GetExtension(fileName);
if(extension != idRenderModel_MD5.MeshExtension)
{
lexer.Warning("Invalid model for MD5 mesh");
MakeDefault();
return false;
}
_model = idE.RenderModelManager.FindModel(fileName);
if(_model == null)
{
lexer.Warning("Model '{0}' not found", fileName);
MakeDefault();
return false;
}
else if(_model.IsDefault == true)
{
lexer.Warning("Model '{0}' defaulted", fileName);
MakeDefault();
return false;
}
// get the number of joints
count = _model.JointCount;
if(count == 0)
{
lexer.Warning("Model '{0}' has no joints", fileName);
}
// set up the joint hierarchy
md5Joints = _model.Joints;
_joints = new JointInfo[count];
_jointParents = new int[count];
_channelJoints = new int[(int) AnimationChannel.Count][];
_channelJoints[0] = new int[count];
for(int i = 0; i < count; i++)
{
_joints[i] = new JointInfo();
_joints[i].Channel = AnimationChannel.All;
_joints[i].Index = i;
if(md5Joints[i].Parent != null)
{
_joints[i].ParentIndex = _model.GetJointIndex(md5Joints[i].Parent);
}
else
{
_joints[i].ParentIndex = -1;
}
_jointParents[i] = _joints[i].ParentIndex;
_channelJoints[0][i] = i;
}
}
else if(tokenValue == "remove")
{
idConsole.Warning("TODO: remove");
// removes any anims whos name matches
/*if( !src.ReadToken( &token2 ) ) {
src.Warning( "Unexpected end of file" );
MakeDefault();
return false;
}
num = 0;
for( i = 0; i < anims.Num(); i++ ) {
if ( ( token2 == anims[ i ]->Name() ) || ( token2 == anims[ i ]->FullName() ) ) {
delete anims[ i ];
anims.RemoveIndex( i );
if ( i >= numDefaultAnims ) {
src.Warning( "Anim '%s' was not inherited. Anim should be removed from the model def.", token2.c_str() );
MakeDefault();
return false;
}
i--;
numDefaultAnims--;
num++;
continue;
}
}
if ( !num ) {
src.Warning( "Couldn't find anim '%s' to remove", token2.c_str() );
MakeDefault();
return false;
}*/
}
else if(tokenValue == "anim")
{
if(_model == null)
{
lexer.Warning("Must specify mesh before defining anims");
MakeDefault();
return false;
}
else if(ParseAnimation(lexer, defaultAnimationCount) == false)
{
MakeDefault();
return false;
}
}
else if(tokenValue == "offset")
{
float[] tmp = lexer.Parse1DMatrix(3);
if(tmp == null)
{
lexer.Warning("Expected vector following 'offset'");
MakeDefault();
return false;
}
_offset = new Vector3(tmp[0], tmp[1], tmp[2]);
}
else if(tokenValue == "channel")
{
if(_model == null)
{
lexer.Warning("Must specify mesh before defining channels");
MakeDefault();
return false;
}
// set the channel for a group of joints
if((token2 = lexer.ReadToken()) == null)
{
lexer.Warning("Unexpected end of file");
MakeDefault();
return false;
}
if(lexer.CheckTokenString("(") == false)
{
lexer.Warning("Expected { after '{0}'", token2.ToString());
MakeDefault();
return false;
}
int i;
int channelCount = (int) AnimationChannel.Count;
for(i = (int) AnimationChannel.All + 1; i < channelCount; i++)
{
if(ChannelNames[i].Equals(token2.ToString(), StringComparison.OrdinalIgnoreCase) == true)
{
break;
}
}
if(i >= channelCount)
{
lexer.Warning("Unknown channel '{0}'", token2.ToString());
MakeDefault();
return false;
}
int channel = i;
StringBuilder jointNames = new StringBuilder();
string token2Value;
while(lexer.CheckTokenString(")") == false)
{
if((token2 = lexer.ReadToken()) == null)
{
lexer.Warning("Unexpected end of file");
MakeDefault();
return false;
}
token2Value = token2.ToString();
jointNames.Append(token2Value);
if((token2Value != "*") && (token2Value != "-"))
{
jointNames.Append(" ");
}
}
int[] jointList = GetJointList(jointNames.ToString());
int jointLength = jointList.Length;
List<int> channelJoints = new List<int>();
for(count = i = 0; i < jointLength; i++)
{
int jointIndex = jointList[i];
if(_joints[jointIndex].Channel != AnimationChannel.All)
{
lexer.Warning("Join '{0}' assigned to multiple channels", _model.GetJointName(jointIndex));
continue;
}
_joints[jointIndex].Channel = (AnimationChannel) channel;
channelJoints.Add(jointIndex);
}
_channelJoints[channel] = channelJoints.ToArray();
}
else
{
lexer.Warning("unknown token '{0}'", token.ToString());
MakeDefault();
return false;
}
}
return true;
}
private bool ParseAnimation(idLexer lexer, int defaultAnimCount)
{
List<idMD5Anim> md5anims = new List<idMD5Anim>();
idMD5Anim md5anim;
idAnim anim;
AnimationFlags flags = new AnimationFlags();
idToken token;
idToken realName = lexer.ReadToken();
if(realName == null)
{
lexer.Warning("Unexpected end of file");
MakeDefault();
return false;
}
string alias = realName.ToString();
int i;
int count = _anims.Count;
for(i = 0; i < count; i++)
{
if(_anims[i].FullName.Equals(alias, StringComparison.OrdinalIgnoreCase) == true)
{
break;
}
}
if((i < count) && (i >= defaultAnimCount))
{
lexer.Warning("Duplicate anim '{0}'", realName);
MakeDefault();
return false;
}
if(i < defaultAnimCount)
{
anim = _anims[i];
}
else
{
// create the alias associated with this animation
anim = new idAnim();
_anims.Add(anim);
}
// random anims end with a number. find the numeric suffix of the animation.
int len = alias.Length;
for(i = len - 1; i > 0; i--)
{
if(Char.IsNumber(alias[i]) == false)
{
break;
}
}
// check for zero length name, or a purely numeric name
if(i <= 0)
{
lexer.Warning("Invalid animation name '{0}'", alias);
MakeDefault();
return false;
}
// remove the numeric suffix
alias = alias.Substring(0, i + 1);
// parse the anims from the string
do
{
if((token = lexer.ReadToken()) == null)
{
lexer.Warning("Unexpected end of file");
MakeDefault();
return false;
}
// lookup the animation
md5anim = idR.AnimManager.GetAnimation(token.ToString());
if(md5anim == null)
{
lexer.Warning("Couldn't load anim '{0}'", token);
return false;
}
md5anim.CheckModelHierarchy(_model);
if(md5anims.Count > 0)
{
// make sure it's the same length as the other anims
if(md5anim.Length != md5anims[0].Length)
{
lexer.Warning("Anim '{0}' does not match length of anim '{1}'", md5anim.Name, md5anims[0].Name);
MakeDefault();
return false;
}
}
// add it to our list
md5anims.Add(md5anim);
}
while(lexer.CheckTokenString(",") == true);
if(md5anims.Count == 0)
{
lexer.Warning("No animation specified");
MakeDefault();
return false;
}
anim.SetAnimation(this, realName.ToString(), alias, md5anims.ToArray());
// parse any frame commands or animflags
if(lexer.CheckTokenString("{") == true)
{
while(true)
{
if((token = lexer.ReadToken()) == null)
{
lexer.Warning("Unexpected end of file");
MakeDefault();
return false;
}
string tokenValue = token.ToString();
if(tokenValue == "}")
{
break;
}
else if(tokenValue == "prevent_idle_override")
{
flags.PreventIdleOverride = true;
}
else if(tokenValue == "random_cycle_start")
{
flags.RandomCycleStart = true;
}
else if(tokenValue == "ai_no_turn")
{
flags.AINoTurn = true;
}
else if(tokenValue == "anim_turn")
{
flags.AnimationTurn = true;
}
else if(tokenValue == "frame")
{
// create a frame command
int frameIndex;
string err;
// make sure we don't have any line breaks while reading the frame command so the error line # will be correct
if((token = lexer.ReadTokenOnLine()) == null)
{
lexer.Warning("Missing frame # after 'frame'");
MakeDefault();
return false;
}
else if((token.Type == TokenType.Punctuation) && (token.ToString() == "-"))
{
lexer.Warning("Invalid frame # after 'frame'");
MakeDefault();
return false;
}
else if((token.Type != TokenType.Number) || (token.SubType == TokenSubType.Float))
{
lexer.Error("expected integer value, found '{0}'", token);
}
// get the frame number
frameIndex = token.ToInt32();
// put the command on the specified frame of the animation
if((err = anim.AddFrameCommand(this, frameIndex, lexer, null)) != null)
{
lexer.Warning(err.ToString());
MakeDefault();
return false;
}
}
else
{
lexer.Warning("Unknown command '{0}'", token);
MakeDefault();
return false;
}
}
}
// set the flags
anim.Flags = flags;
return true;
}
