private void ParseJoint(idLexer lexer, idMD5Joint joint, ref idJointQuaternion defaultPose)
{
//
// parse name
//
joint.Name = lexer.ReadToken().ToString();
//
// parse parent
//
int parentIndex = lexer.ParseInt();
if(parentIndex >= 0)
{
if(parentIndex >= (_joints.Length - 1))
{
lexer.Error("Invalid parent for joint '{0}'", joint.Name);
}
joint.Parent = _joints[parentIndex];
}
//
// parse default pose
//
float[] tmp = lexer.Parse1DMatrix(3);
defaultPose.Translation = new Vector3(tmp[0], tmp[1], tmp[2]);
tmp = lexer.Parse1DMatrix(3);
defaultPose.Quaternion = new Quaternion(tmp[0], tmp[1], tmp[2], 0);
defaultPose.Quaternion.W = idHelper.CalculateW(defaultPose.Quaternion);
}
public bool LoadAnimation(string fileName)
{
idToken token;
idLexer lexer = new idLexer(LexerOptions.AllowPathNames | LexerOptions.NoStringEscapeCharacters | LexerOptions.NoStringConcatination);
if(lexer.LoadFile(fileName) == false)
{
return false;
}
Clear();
_name = fileName;
lexer.ExpectTokenString(idRenderModel_MD5.VersionString);
int version = lexer.ParseInt();
if(version != idRenderModel_MD5.Version)
{
lexer.Error("Invalid version {0}. Should be version {1}", version, idRenderModel_MD5.Version);
}
// skip the commandline
lexer.ExpectTokenString("commandline");
lexer.ReadToken();
// parse num frames
lexer.ExpectTokenString("numFrames");
int frameCount = lexer.ParseInt();
if(frameCount <= 0)
{
lexer.Error("Invalid number of frames: {0}", frameCount);
}
// parse num joints
lexer.ExpectTokenString("numJoints");
int jointCount = lexer.ParseInt();
if(jointCount <= 0)
{
lexer.Error("Invalid number of joints: {0}", jointCount);
}
// parse frame rate
lexer.ExpectTokenString("frameRate");
_frameRate = lexer.ParseInt();
if(_frameRate < 0)
{
lexer.Error("Invalid frame rate: {0}", _frameRate);
}
// parse number of animated components
lexer.ExpectTokenString("numAnimatedComponents");
_animatedComponentCount = lexer.ParseInt();
if((_animatedComponentCount < 0) || (_animatedComponentCount > (jointCount * 6)))
{
lexer.Error("Invalid number of animated components: {0}", _animatedComponentCount);
}
// parse the hierarchy
_jointInfo = new JointAnimationInfo[jointCount];
lexer.ExpectTokenString("hierarchy");
lexer.ExpectTokenString("{");
for(int i = 0; i < jointCount; i++)
{
token = lexer.ReadToken();
_jointInfo[i] = new JointAnimationInfo();
_jointInfo[i].NameIndex = idR.AnimManager.GetJointIndex(token.ToString());
// parse parent num
_jointInfo[i].ParentIndex = lexer.ParseInt();
if(_jointInfo[i].ParentIndex >= i)
{
lexer.Error("Invalid parent num: {0}", _jointInfo[i].ParentIndex);
}
if((i != 0) && (_jointInfo[i].ParentIndex < 0))
{
lexer.Error("Animations may have only one root joint");
}
// parse anim bits
_jointInfo[i].AnimationBits = (AnimationBits) lexer.ParseInt();
if(((int) _jointInfo[i].AnimationBits & ~63) != 0)
{
lexer.Error("Invalid anim bits: {0}", _jointInfo[i].AnimationBits);
}
// parse first component
_jointInfo[i].FirstComponent = lexer.ParseInt();
if((_animatedComponentCount > 0) && ((_jointInfo[i].FirstComponent < 0) || (_jointInfo[i].FirstComponent >= _animatedComponentCount)))
{
lexer.Error("Invalid first component: {0}", _jointInfo[i].FirstComponent);
}
}
lexer.ExpectTokenString("}");
// parse bounds
lexer.ExpectTokenString("bounds");
lexer.ExpectTokenString("{");
_bounds = new idBounds[frameCount];
for(int i = 0; i < frameCount; i++)
{
float[] tmp = lexer.Parse1DMatrix(3);
float[] tmp2 = lexer.Parse1DMatrix(3);
_bounds[i] = new idBounds(
new Vector3(tmp[0], tmp[1], tmp[2]),
new Vector3(tmp2[0], tmp2[1], tmp2[2])
);
}
lexer.ExpectTokenString("}");
// parse base frame
_baseFrame = new idJointQuaternion[jointCount];
lexer.ExpectTokenString("baseframe");
lexer.ExpectTokenString("{");
for(int i = 0; i < jointCount; i++)
{
float[] tmp = lexer.Parse1DMatrix(3);
float[] tmp2 = lexer.Parse1DMatrix(3);
idCompressedQuaternion q = new idCompressedQuaternion(tmp2[0], tmp2[1], tmp2[2]);
_baseFrame[i] = new idJointQuaternion();
_baseFrame[i].Translation = new Vector3(tmp[0], tmp[1], tmp[2]);
_baseFrame[i].Quaternion = q.ToQuaternion();
}
lexer.ExpectTokenString("}");
// parse frames
_componentFrames = new float[_animatedComponentCount * frameCount];
int frameOffset = 0;
for(int i = 0; i < frameCount; i++)
{
lexer.ExpectTokenString("frame");
int count = lexer.ParseInt();
if(count != i)
{
lexer.Error("Expected frame number {0}", i);
}
lexer.ExpectTokenString("{");
for(int j = 0; j < _animatedComponentCount; j++, frameOffset++)
{
_componentFrames[frameOffset] = lexer.ParseFloat();
}
lexer.ExpectTokenString("}");
}
// get total move delta
if(_animatedComponentCount == 0)
{
_totalDelta = Vector3.Zero;
}
else
{
int componentOffset = _jointInfo[0].FirstComponent;
if((_jointInfo[0].AnimationBits & AnimationBits.TranslationX) == AnimationBits.TranslationX)
{
for(int i = 0; i < frameCount; i++)
{
_componentFrames[componentOffset + (_animatedComponentCount * i)] -= _baseFrame[0].Translation.X;
}
_totalDelta.X = _componentFrames[componentOffset + (_animatedComponentCount * (frameCount - 1))];
componentOffset++;
}
else
{
_totalDelta.X = 0;
}
if((_jointInfo[0].AnimationBits & AnimationBits.TranslationY) == AnimationBits.TranslationY)
{
for(int i = 0; i < frameCount; i++)
{
_componentFrames[componentOffset + (_animatedComponentCount * i)] -= _baseFrame[0].Translation.Y;
}
_totalDelta.Y = _componentFrames[componentOffset + (_animatedComponentCount * (frameCount - 1))];
componentOffset++;
}
else
{
_totalDelta.Y = 0;
}
if((_jointInfo[0].AnimationBits & AnimationBits.TranslationZ) == AnimationBits.TranslationZ)
{
for(int i = 0; i < frameCount; i++)
{
_componentFrames[componentOffset + (_animatedComponentCount * i)] -= _baseFrame[0].Translation.Z;
}
_totalDelta.Z = _componentFrames[componentOffset + (_animatedComponentCount * (frameCount - 1))];
}
else
{
_totalDelta.Z = 0;
}
}
_baseFrame[0].Translation = Vector3.Zero;
// we don't count last frame because it would cause a 1 frame pause at the end
_animLength = ((frameCount - 1) * 1000 + _frameRate - 1) / _frameRate;
// done
return true;
}
public static idMapBrush ParseQ3(idLexer lexer, Vector3 origin)
{
int rotate;
int[] shift = new int[2];
float[] scale = new float[2];
Vector3[] planePoints = new Vector3[3];
List<idMapBrushSide> sides = new List<idMapBrushSide>();
idMapBrushSide side;
idToken token;
do
{
if(lexer.CheckTokenString("}") == true)
{
break;
}
side = new idMapBrushSide();
sides.Add(side);
// read the three point plane definition
float[] tmp = lexer.Parse1DMatrix(3);
float[] tmp2 = lexer.Parse1DMatrix(3);
float[] tmp3 = lexer.Parse1DMatrix(3);
if((tmp == null) || (tmp2 == null) || (tmp3 == null))
{
lexer.Error("idMapBrush::ParseQ3: unable to read brush side plane definition");
return null;
}
planePoints[0] = new Vector3(tmp[0], tmp[1], tmp[2]) - origin;
planePoints[1] = new Vector3(tmp2[0], tmp2[1], tmp2[2]) - origin;
planePoints[2] = new Vector3(tmp3[0], tmp3[1], tmp3[2]) - origin;
side.Plane.FromPoints(planePoints[0], planePoints[1], planePoints[2]);
// read the material
token = lexer.ReadTokenOnLine();
if(token == null)
{
lexer.Error("idMapBrush::ParseQ3: unable to read brush side material");
return null;
}
// we have an implicit 'textures/' in the old format
side.Material = "textures/" + token.ToString();
// read the texture shift, rotate and scale
shift[0] = lexer.ParseInt();
shift[1] = lexer.ParseInt();
rotate = lexer.ParseInt();
scale[0] = lexer.ParseFloat();
scale[1] = lexer.ParseFloat();
side.TextureMatrix[0] = new Vector3(0.03125f, 0.0f, 0.0f);
side.TextureMatrix[1] = new Vector3(0.0f, 0.03125f, 0.0f);
side.Origin = origin;
// Q2 allowed override of default flags and values, but we don't any more
if(lexer.ReadTokenOnLine() != null)
{
if(lexer.ReadTokenOnLine() != null)
{
if(lexer.ReadTokenOnLine() != null)
{
}
}
}
}
while(true);
idMapBrush brush = new idMapBrush();
for(int i = 0; i < sides.Count; i++)
{
brush.AddSide(sides[i]);
}
brush.Dict = new idDict();
return brush;
}
private void ParseVertices(idLexer lexer, CollisionModel model)
{
lexer.ExpectTokenString("{");
int vertexCount = lexer.ParseInt();
model.Vertices = new CollisionModelVertex[vertexCount];
for(int i = 0; i < vertexCount; i++)
{
float[] tmp = lexer.Parse1DMatrix(3);
model.Vertices[i].Point = new Vector3(tmp[0], tmp[1], tmp[2]);
model.Vertices[i].Side = 0;
model.Vertices[i].SideSet = 0;
model.Vertices[i].CheckCount = 0;
}
lexer.ExpectTokenString("}");
}
private void ParsePolygons(idLexer lexer, CollisionModel model)
{
idToken token = lexer.CheckTokenType(TokenType.Number, 0);
float[] tmp;
Vector3 normal;
lexer.ExpectTokenString("{");
while(lexer.CheckTokenString("}") == false)
{
// parse polygon
int edgeCount = lexer.ParseInt();
CollisionModelPolygon p = new CollisionModelPolygon();
p.Material = _traceModelMaterial;
p.Contents = ContentFlags.All;
p.Edges = new int[edgeCount];
lexer.ExpectTokenString("(");
for(int i = 0; i < edgeCount; i++)
{
p.Edges[i] = lexer.ParseInt();
}
lexer.ExpectTokenString(")");
tmp = lexer.Parse1DMatrix(3);
normal = new Vector3(tmp[0], tmp[1], tmp[2]);
p.Plane.Normal = normal;
p.Plane.D = lexer.ParseFloat();
tmp = lexer.Parse1DMatrix(3);
p.Bounds.Min = new Vector3(tmp[0], tmp[1], tmp[2]);
tmp = lexer.Parse1DMatrix(3);
p.Bounds.Max = new Vector3(tmp[0], tmp[1], tmp[2]);
token = lexer.ExpectTokenType(TokenType.String, 0);
// get material
p.Material = idE.DeclManager.FindMaterial(token.ToString());
p.Contents = p.Material.ContentFlags;
p.CheckCount = 0;
// filter polygon into tree
FilterPolygonIntoTree(model, model.Node, p);
}
}
private CollisionModelNode ParseNodes(idLexer lexer, CollisionModel model, CollisionModelNode parent)
{
model.NodeCount++;
lexer.ExpectTokenString("(");
CollisionModelNode node = new CollisionModelNode();
node.Parent = parent;
node.PlaneType = lexer.ParseInt();
node.PlaneDistance = lexer.ParseFloat();
lexer.ExpectTokenString(")");
if(node.PlaneType != -1)
{
node.Children[0] = ParseNodes(lexer, model, node);
node.Children[1] = ParseNodes(lexer, model, node);
}
return node;
}
private void ParseEdges(idLexer lexer, CollisionModel model)
{
lexer.ExpectTokenString("{");
int edgeCount = lexer.ParseInt();
model.Edges = new CollisionModelEdge[edgeCount];
for(int i = 0; i < edgeCount; i++)
{
lexer.ExpectTokenString("(");
model.Edges[i].VertexCount = new int[] { lexer.ParseInt(), lexer.ParseInt() };
lexer.ExpectTokenString(")");
model.Edges[i].Side = 0;
model.Edges[i].SideSet = 0;
model.Edges[i].Internal = (ushort) lexer.ParseInt();
model.Edges[i].UserCount = (ushort) lexer.ParseInt();
model.Edges[i].Normal = Vector3.Zero;
model.Edges[i].CheckCount = 0;
model.InternalEdgeCount += model.Edges[i].Internal;
}
lexer.ExpectTokenString("}");
}
private void ParseBrushes(idLexer lexer, CollisionModel model)
{
idToken token = lexer.CheckTokenType(TokenType.Number, 0);
int planeCount;
CollisionModelBrush b;
float[] tmp;
lexer.ExpectTokenString("{");
while(lexer.CheckTokenString("}") == false)
{
// parse brush
planeCount = lexer.ParseInt();
b = new CollisionModelBrush();
b.Contents = ContentFlags.All;
b.Material = _traceModelMaterial;
b.Planes = new Plane[planeCount];
lexer.ExpectTokenString("{");
for(int i = 0; i < planeCount; i++)
{
tmp = lexer.Parse1DMatrix(3);
b.Planes[i].Normal = new Vector3(tmp[0], tmp[1], tmp[2]);
b.Planes[i].D = lexer.ParseFloat();
}
lexer.ExpectTokenString("}");
tmp = lexer.Parse1DMatrix(3);
b.Bounds.Min = new Vector3(tmp[0], tmp[1], tmp[2]);
tmp = lexer.Parse1DMatrix(3);
b.Bounds.Max = new Vector3(tmp[0], tmp[1], tmp[2]);
token = lexer.ReadToken();
if(token.Type == TokenType.Number)
{
b.Contents = (ContentFlags) token.ToInt32(); // old .cm files use a single integer
}
else
{
b.Contents = ContentsFromString(token.ToString());
}
b.CheckCount = 0;
b.PrimitiveCount = 0;
// filter brush into tree
FilterBrushIntoTree(model, model.Node, b);
}
}
private void ParseStage(idLexer lexer, TextureRepeat textureRepeatDefault)
{
TextureFilter textureFilter = TextureFilter.Default;
TextureRepeat textureRepeat = textureRepeatDefault;
TextureDepth textureDepth = TextureDepth.Default;
CubeFiles cubeMap = CubeFiles.TwoD;
bool allowPicmip = true;
string imageName = string.Empty;
NewMaterialStage newStage = new NewMaterialStage();
newStage.VertexParameters = new int[4, 4];
MaterialStage materialStage = new MaterialStage();
materialStage.ConditionRegister = GetExpressionConstant(1);
materialStage.Color.Registers = new int[] {
GetExpressionConstant(1),
GetExpressionConstant(1),
GetExpressionConstant(1),
GetExpressionConstant(1)
};
int[,] matrix = new int[2, 3];
idToken token;
int a, b;
string tokenValue;
string tokenLower;
while(true)
{
if(TestMaterialFlag(MaterialFlags.Defaulted) == true)
{
// we have a parse error
return;
}
else if((token = lexer.ExpectAnyToken()) == null)
{
this.MaterialFlag = MaterialFlags.Defaulted;
return;
}
tokenValue = token.ToString();
tokenLower = tokenValue.ToLower();
// the close brace for the entire material ends the draw block
if(tokenLower == "}")
{
break;
}
// BSM Nerve: Added for stage naming in the material editor
else if(tokenLower == "name")
{
lexer.SkipRestOfLine();
}
// image options
else if(tokenLower == "blend")
{
ParseBlend(lexer, ref materialStage);
}
else if(tokenLower == "map")
{
imageName = ParsePastImageProgram(lexer);
}
else if(tokenLower == "remoterendermap")
{
materialStage.Texture.Dynamic = DynamicImageType.RemoteRender;
materialStage.Texture.Width = lexer.ParseInt();
materialStage.Texture.Height = lexer.ParseInt();
}
else if(tokenLower == "mirrorrendermap")
{
materialStage.Texture.Dynamic = DynamicImageType.MirrorRender;
materialStage.Texture.Width = lexer.ParseInt();
materialStage.Texture.Height = lexer.ParseInt();
materialStage.Texture.TextureCoordinates = TextureCoordinateGeneration.Screen;
}
else if(tokenLower == "xrayrendermap")
{
materialStage.Texture.Dynamic = DynamicImageType.XRayRender;
materialStage.Texture.Width = lexer.ParseInt();
materialStage.Texture.Height = lexer.ParseInt();
materialStage.Texture.TextureCoordinates = TextureCoordinateGeneration.Screen;
}
else if(tokenLower == "screen")
{
materialStage.Texture.TextureCoordinates = TextureCoordinateGeneration.Screen;
}
else if(tokenLower == "screen2")
{
materialStage.Texture.TextureCoordinates = TextureCoordinateGeneration.Screen;
}
else if(tokenLower == "glasswarp")
{
materialStage.Texture.TextureCoordinates = TextureCoordinateGeneration.GlassWarp;
}
else if(tokenLower == "videomap")
{
// note that videomaps will always be in clamp mode, so texture
// coordinates had better be in the 0 to 1 range
if((token = lexer.ReadToken()) == null)
{
idConsole.Warning("missing parameter for 'videoMap' keyword in material '{0}'", this.Name);
}
else
{
bool loop = false;
if(token.ToString().Equals("loop", StringComparison.OrdinalIgnoreCase) == true)
{
loop = true;
if((token = lexer.ReadToken()) == null)
{
idConsole.Warning("missing parameter for 'videoMap' keyword in material '{0}'", this.Name);
continue;
}
}
idConsole.Warning("TODO: material videoMap keyword");
// TODO: cinematic
/*ts->cinematic = idCinematic::Alloc();
ts->cinematic->InitFromFile( token.c_str(), loop );*/
}
}
else if(tokenLower == "soundmap")
{
if((token = lexer.ReadToken()) == null)
{
idConsole.Warning("missing parameter for 'soundMap' keyword in material '{0}'", this.Name);
}
else
{
idConsole.Warning("TODO: material soundMap keyword");
// TODO
/*ts->cinematic = new idSndWindow();
ts->cinematic->InitFromFile( token.c_str(), true );*/
}
}
else if(tokenLower == "cubemap")
{
imageName = ParsePastImageProgram(lexer);
cubeMap = CubeFiles.Native;
}
else if(tokenLower == "cameracubemap")
{
imageName = ParsePastImageProgram(lexer);
cubeMap = CubeFiles.Camera;
}
else if(tokenLower == "ignorealphatest")
{
materialStage.IgnoreAlphaTest = true;
}
else if(tokenLower == "nearest")
{
textureFilter = TextureFilter.Nearest;
}
else if(tokenLower == "linear")
{
textureFilter = TextureFilter.Linear;
}
else if(tokenLower == "clamp")
{
textureRepeat = TextureRepeat.Clamp;
}
else if(tokenLower == "noclamp")
{
textureRepeat = TextureRepeat.Repeat;
}
else if(tokenLower == "zeroclamp")
{
textureRepeat = TextureRepeat.ClampToZero;
}
else if(tokenLower == "alphazeroclamp")
{
textureRepeat = TextureRepeat.ClampToZeroAlpha;
}
else if((tokenLower == "uncompressed")
|| (tokenLower == "highquality"))
{
if(idE.CvarSystem.GetInteger("image_ignoreHighQuality") == 0)
{
textureDepth = TextureDepth.HighQuality;
}
}
else if(tokenLower == "forcehighquality")
{
textureDepth = TextureDepth.HighQuality;
}
else if(tokenLower == "nopicmip")
{
allowPicmip = false;
}
else if(tokenLower == "vertexcolor")
{
materialStage.VertexColor = StageVertexColor.Modulate;
}
else if(tokenLower == "inversevertexcolor")
{
materialStage.VertexColor = StageVertexColor.InverseModulate;
}
// privatePolygonOffset
else if(tokenLower == "privatepolygonoffset")
{
if((token = lexer.ReadTokenOnLine()) == null)
{
materialStage.PrivatePolygonOffset = 1;
}
else
{
// explict larger (or negative) offset
lexer.UnreadToken = token;
materialStage.PrivatePolygonOffset = lexer.ParseFloat();
}
}
// texture coordinate generation
else if(tokenLower == "texgen")
{
token = lexer.ExpectAnyToken();
tokenValue = token.ToString();
tokenLower = tokenValue.ToLower();
if(tokenLower == "normal")
{
materialStage.Texture.TextureCoordinates = TextureCoordinateGeneration.DiffuseCube;
}
else if(tokenLower == "reflect")
{
materialStage.Texture.TextureCoordinates = TextureCoordinateGeneration.ReflectCube;
}
else if(tokenLower == "skybox")
{
materialStage.Texture.TextureCoordinates = TextureCoordinateGeneration.SkyboxCube;
}
else if(tokenLower == "wobblesky")
{
materialStage.Texture.TextureCoordinates = TextureCoordinateGeneration.WobbleSkyCube;
_texGenRegisters = new int[4];
_texGenRegisters[0] = ParseExpression(lexer);
_texGenRegisters[1] = ParseExpression(lexer);
_texGenRegisters[2] = ParseExpression(lexer);
}
else
{
idConsole.Warning("bad texGen '{0}' in material {1}", tokenValue, this.Name);
this.MaterialFlag = MaterialFlags.Defaulted;
}
}
else if((tokenLower == "scroll")
|| (tokenLower == "translate"))
{
a = ParseExpression(lexer);
MatchToken(lexer, ",");
b = ParseExpression(lexer);
matrix[0, 0] = GetExpressionConstant(1);
matrix[0, 1] = GetExpressionConstant(0);
matrix[0, 2] = a;
matrix[1, 0] = GetExpressionConstant(0);
matrix[1, 1] = GetExpressionConstant(1);
matrix[1, 2] = b;
MultiplyTextureMatrix(ref materialStage.Texture, matrix);
}
else if(tokenLower == "scale")
{
a = ParseExpression(lexer);
MatchToken(lexer, ",");
b = ParseExpression(lexer);
// this just scales without a centering
matrix[0, 0] = a;
matrix[0, 1] = GetExpressionConstant(0);
matrix[0, 2] = GetExpressionConstant(0);
matrix[1, 0] = GetExpressionConstant(0);
matrix[1, 1] = b;
matrix[1, 2] = GetExpressionConstant(0);
MultiplyTextureMatrix(ref materialStage.Texture, matrix);
}
else if(tokenLower == "centerscale")
{
a = ParseExpression(lexer);
MatchToken(lexer, ",");
b = ParseExpression(lexer);
// this subtracts 0.5, then scales, then adds 0.5
matrix[0, 0] = a;
matrix[0, 1] = GetExpressionConstant(0);
matrix[0, 2] = EmitOp(GetExpressionConstant(0.5f), EmitOp(GetExpressionConstant(0.5f), a, ExpressionOperationType.Multiply), ExpressionOperationType.Subtract);
matrix[1, 0] = GetExpressionConstant(0);
matrix[1, 1] = b;
matrix[1, 2] = EmitOp(GetExpressionConstant(0.5f), EmitOp(GetExpressionConstant(0.5f), b, ExpressionOperationType.Multiply), ExpressionOperationType.Subtract);
MultiplyTextureMatrix(ref materialStage.Texture, matrix);
}
else if(tokenLower == "shear")
{
a = ParseExpression(lexer);
MatchToken(lexer, ",");
b = ParseExpression(lexer);
// this subtracts 0.5, then shears, then adds 0.5
matrix[0, 0] = GetExpressionConstant(1);
matrix[0, 1] = a;
matrix[0, 2] = EmitOp(GetExpressionConstant(-0.5f), a, ExpressionOperationType.Multiply);
matrix[1, 0] = b;
matrix[1, 1] = GetExpressionConstant(1);
matrix[1, 2] = EmitOp(GetExpressionConstant(-0.5f), b, ExpressionOperationType.Multiply);
MultiplyTextureMatrix(ref materialStage.Texture, matrix);
}
else if(tokenLower == "rotate")
{
int sinReg, cosReg;
// in cycles
a = ParseExpression(lexer);
idDeclTable table = idE.DeclManager.FindType<idDeclTable>(DeclType.Table, "sinTable", false);
if(table == null)
{
idConsole.Warning("no sinTable for rotate defined");
this.MaterialFlag = MaterialFlags.Defaulted;
return;
}
sinReg = EmitOp(table.Index, a, ExpressionOperationType.Table);
table = idE.DeclManager.FindType<idDeclTable>(DeclType.Table, "cosTable", false);
if(table == null)
{
idConsole.Warning("no cosTable for rotate defined");
this.MaterialFlag = MaterialFlags.Defaulted;
return;
}
cosReg = EmitOp(table.Index, a, ExpressionOperationType.Table);
// this subtracts 0.5, then rotates, then adds 0.5
matrix[0, 0] = cosReg;
matrix[0, 1] = EmitOp(GetExpressionConstant(0), sinReg, ExpressionOperationType.Subtract);
matrix[0, 2] = EmitOp(EmitOp(EmitOp(GetExpressionConstant(-0.5f), cosReg, ExpressionOperationType.Multiply),
EmitOp(GetExpressionConstant(0.5f), sinReg, ExpressionOperationType.Multiply), ExpressionOperationType.Add),
GetExpressionConstant(0.5f), ExpressionOperationType.Add);
matrix[1, 0] = sinReg;
matrix[1, 1] = cosReg;
matrix[1, 2] = EmitOp(EmitOp(EmitOp(GetExpressionConstant(-0.5f), sinReg, ExpressionOperationType.Multiply),
EmitOp(GetExpressionConstant(-0.5f), cosReg, ExpressionOperationType.Multiply), ExpressionOperationType.Add),
GetExpressionConstant(0.5f), ExpressionOperationType.Add);
MultiplyTextureMatrix(ref materialStage.Texture, matrix);
}
// color mask options
else if(tokenLower == "maskred")
{
materialStage.DrawStateBits |= MaterialStates.RedMask;
}
else if(tokenLower == "maskgreen")
{
materialStage.DrawStateBits |= MaterialStates.GreenMask;
}
else if(tokenLower == "maskblue")
{
materialStage.DrawStateBits |= MaterialStates.BlueMask;
}
else if(tokenLower == "maskalpha")
{
materialStage.DrawStateBits |= MaterialStates.AlphaMask;
}
else if(tokenLower == "maskcolor")
{
materialStage.DrawStateBits |= MaterialStates.ColorMask;
}
else if(tokenLower == "maskdepth")
{
materialStage.DrawStateBits |= MaterialStates.DepthMask;
}
else if(tokenLower == "alphatest")
{
materialStage.HasAlphaTest = true;
materialStage.AlphaTestRegister = ParseExpression(lexer);
_coverage = MaterialCoverage.Perforated;
}
// shorthand for 2D modulated
else if(tokenLower == "colored")
{
materialStage.Color.Registers[0] = (int) ExpressionRegister.Parm0;
materialStage.Color.Registers[1] = (int) ExpressionRegister.Parm1;
materialStage.Color.Registers[2] = (int) ExpressionRegister.Parm2;
materialStage.Color.Registers[3] = (int) ExpressionRegister.Parm3;
_parsingData.RegistersAreConstant = false;
}
else if(tokenLower == "color")
{
materialStage.Color.Registers[0] = ParseExpression(lexer);
MatchToken(lexer, ",");
materialStage.Color.Registers[1] = ParseExpression(lexer);
MatchToken(lexer, ",");
materialStage.Color.Registers[2] = ParseExpression(lexer);
MatchToken(lexer, ",");
materialStage.Color.Registers[3] = ParseExpression(lexer);
}
else if(tokenLower == "red")
{
materialStage.Color.Registers[0] = ParseExpression(lexer);
}
else if(tokenLower == "green")
{
materialStage.Color.Registers[1] = ParseExpression(lexer);
}
else if(tokenLower == "blue")
{
materialStage.Color.Registers[2] = ParseExpression(lexer);
}
else if(tokenLower == "alpha")
{
materialStage.Color.Registers[3] = ParseExpression(lexer);
}
else if(tokenLower == "rgb")
{
materialStage.Color.Registers[0] = materialStage.Color.Registers[1] = materialStage.Color.Registers[2] = ParseExpression(lexer);
}
else if(tokenLower == "rgba")
{
materialStage.Color.Registers[0] = materialStage.Color.Registers[1] = materialStage.Color.Registers[2] = materialStage.Color.Registers[3] = ParseExpression(lexer);
}
else if(tokenLower == "if")
{
materialStage.ConditionRegister = ParseExpression(lexer);
}
else if(tokenLower == "program")
{
if((token = lexer.ReadTokenOnLine()) != null)
{
idConsole.Warning("TODO: material program keyword");
// TODO
/*newStage.vertexProgram = R_FindARBProgram( GL_VERTEX_PROGRAM_ARB, token.c_str() );
newStage.fragmentProgram = R_FindARBProgram( GL_FRAGMENT_PROGRAM_ARB, token.c_str() );*/
}
}
else if(tokenLower == "fragmentprogram")
{
if((token = lexer.ReadTokenOnLine()) != null)
{
idConsole.Warning("TODO: material fragmentProgram keyword");
// TODO
//newStage.fragmentProgram = R_FindARBProgram( GL_FRAGMENT_PROGRAM_ARB, token.c_str() );
}
}
else if(tokenLower == "vertexprogram")
{
if((token = lexer.ReadTokenOnLine()) != null)
{
idConsole.Warning("TODO: material vertexProgram keyword");
// TODO
//newStage.vertexProgram = R_FindARBProgram( GL_VERTEX_PROGRAM_ARB, token.c_str() );
}
}
else if(tokenLower == "megatexture")
{
if((token = lexer.ReadTokenOnLine()) != null)
{
idConsole.Warning("TODO: material megaTexture keyword");
// TODO
/*newStage.megaTexture = new idMegaTexture;
if ( !newStage.megaTexture->InitFromMegaFile( token.c_str() ) ) {
delete newStage.megaTexture;
SetMaterialFlag( MF_DEFAULTED );
continue;
}
newStage.vertexProgram = R_FindARBProgram( GL_VERTEX_PROGRAM_ARB, "megaTexture.vfp" );
newStage.fragmentProgram = R_FindARBProgram( GL_FRAGMENT_PROGRAM_ARB, "megaTexture.vfp" );*/
}
}
else if(tokenLower == "vertexparm")
{
ParseVertexParameter(lexer, ref newStage);
}
else if(tokenLower == "fragmentmap")
{
ParseFragmentMap(lexer, ref newStage);
}
else
{
idConsole.Warning("unknown token '{0}' in material '{1}'", tokenValue, this.Name);
this.MaterialFlag = MaterialFlags.Defaulted;
return;
}
}
// if we are using newStage, allocate a copy of it
if((newStage.FragmentProgram != 0) || (newStage.VertexProgram != 0))
{
materialStage.NewStage = newStage;
}
// select a compressed depth based on what the stage is
if(textureDepth == TextureDepth.Default)
{
switch(materialStage.Lighting)
{
case StageLighting.Bump:
textureDepth = TextureDepth.Bump;
break;
case StageLighting.Diffuse:
textureDepth = TextureDepth.Diffuse;
break;
case StageLighting.Specular:
textureDepth = TextureDepth.Specular;
break;
}
}
// now load the image with all the parms we parsed
if((imageName != null) && (imageName != string.Empty))
{
materialStage.Texture.Image = idE.ImageManager.ImageFromFile(imageName, textureFilter, allowPicmip, textureRepeat, textureDepth, cubeMap);
if(materialStage.Texture.Image == null)
{
materialStage.Texture.Image = idE.ImageManager.DefaultImage;
}
}
else if(/*TODO: !ts->cinematic &&*/ (materialStage.Texture.Dynamic == 0) && (materialStage.NewStage.IsEmpty == true))
{
idConsole.Warning("material '{0}' had stage with no image", this.Name);
materialStage.Texture.Image = idE.ImageManager.DefaultImage;
}
// successfully parsed a stage.
_parsingData.Stages.Add(materialStage);
}
/// <summary>
/// Used for initial loads, reloadModel, and reloading the data of purged models.
/// </summary>
/// <remarks>
/// Upon exit, the model will absolutely be valid, but possibly as a default model.
/// </remarks>
public override void Load()
{
if(this.Disposed == true)
{
throw new ObjectDisposedException(this.GetType().Name);
}
if(_purged == false)
{
Purge();
}
_purged = false;
idLexer lexer = new idLexer(LexerOptions.AllowPathNames | LexerOptions.NoStringEscapeCharacters);
if(lexer.LoadFile(Name) == false)
{
MakeDefault();
return;
}
lexer.ExpectTokenString(VersionString);
int version = lexer.ParseInt();
int count = 0;
idToken token;
if(version != Version)
{
lexer.Error("Invalid version {0}. Should be version {1}", version, Version);
}
//
// skip commandline
//
lexer.ExpectTokenString("commandline");
lexer.ReadToken();
// parse num joints
lexer.ExpectTokenString("numJoints");
count = lexer.ParseInt();
_joints = new idMD5Joint[count];
_defaultPose = new idJointQuaternion[count];
idJointMatrix[] poseMat3 = new idJointMatrix[count];
// parse num meshes
lexer.ExpectTokenString("numMeshes");
count = lexer.ParseInt();
if(count < 0)
{
lexer.Error("Invalid size: {0}", count);
}
_meshes = new idMD5Mesh[count];
//
// parse joints
//
lexer.ExpectTokenString("joints");
lexer.ExpectTokenString("{");
int jointCount = _joints.Length;
for(int i = 0; i < jointCount; i++)
{
idMD5Joint joint = _joints[i] = new idMD5Joint();
idJointQuaternion pose = new idJointQuaternion();
ParseJoint(lexer, joint, ref pose);
poseMat3[i] = idJointMatrix.Zero;
poseMat3[i].Rotation = Matrix.CreateFromQuaternion(pose.Quaternion);
poseMat3[i].Translation = pose.Translation;
if(joint.Parent != null)
{
int parentIndex = GetJointIndex(joint.Parent);
pose.Quaternion = Quaternion.CreateFromRotationMatrix(poseMat3[i].ToMatrix()
* Matrix.Transpose(poseMat3[parentIndex].ToMatrix()));
pose.Translation = Vector3.Transform(poseMat3[i].ToVector3() - poseMat3[parentIndex].ToVector3(),
Matrix.Transpose(poseMat3[parentIndex].ToMatrix()));
}
_defaultPose[i] = pose;
}
lexer.ExpectTokenString("}");
int meshCount = _meshes.Length;
for(int i = 0; i < meshCount; i++)
{
lexer.ExpectTokenString("mesh");
_meshes[i] = new idMD5Mesh();
_meshes[i].Parse(lexer, poseMat3);
}
//
// calculate the bounds of the model
//
CalculateBounds(poseMat3);
// set the timestamp for reloadmodels
idConsole.Warning("TODO: fileSystem->ReadFile( name, NULL, &timeStamp );");
}
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);
}
private idRenderModel ParseShadowModel(idLexer lexer)
{
lexer.ExpectTokenString("{");
// parse the name
idToken token = lexer.ExpectAnyToken();
idRenderModel model = idE.RenderModelManager.AllocateModel();
model.InitEmpty(token.ToString());
RenderModelSurface modelSurface = new RenderModelSurface();
modelSurface.Material = idE.RenderSystem.DefaultMaterial;
modelSurface.Geometry = new Surface();
modelSurface.Geometry.ShadowVertices = new ShadowVertex[lexer.ParseInt()];
modelSurface.Geometry.ShadowIndexesNoCapsCount = lexer.ParseInt();
modelSurface.Geometry.ShadowIndexesNoFrontCapsCount = lexer.ParseInt();
modelSurface.Geometry.Indexes = new int[lexer.ParseInt()];
modelSurface.Geometry.ShadowCapPlaneBits = lexer.ParseInt();
modelSurface.Geometry.Bounds.Clear();
int count = modelSurface.Geometry.ShadowVertices.Length;
for(int j = 0; j < count; j++)
{
float[] vec = lexer.Parse1DMatrix(3);
modelSurface.Geometry.ShadowVertices[j].Position = new Vector4(vec[0], vec[1], vec[2], 1);
modelSurface.Geometry.Bounds.AddPoint(modelSurface.Geometry.ShadowVertices[j].Position);
}
count = modelSurface.Geometry.Indexes.Length;
for(int j = 0; j < count; j++)
{
modelSurface.Geometry.Indexes[j] = lexer.ParseInt();
}
// add the completed surface to the model
model.AddSurface(modelSurface);
lexer.ExpectTokenString("}");
// we do NOT do a model->FinishSurfaces, because we don't need sil edges, planes, tangents, etc.
// model.FinishSurfaces();
return model;
}
private void ParseNodes(idLexer lexer)
{
lexer.ExpectTokenString("{");
_areaNodeCount = lexer.ParseInt();
if(_areaNodeCount < 0)
{
lexer.Error("ParseNodes: bad areaNodeCount");
}
_areaNodes = new AreaNode[_areaNodeCount];
float[] tmp;
AreaNode node;
for(int i = 0; i < _areaNodeCount; i++)
{
node = _areaNodes[i] = new AreaNode();
tmp = lexer.Parse1DMatrix(4);
node.Plane = new Plane(tmp[0], tmp[1], tmp[2], tmp[3]);
node.Children[0] = lexer.ParseInt();
node.Children[1] = lexer.ParseInt();
}
lexer.ExpectTokenString("}");
}
private idRenderModel ParseModel(idLexer lexer)
{
if(this.Disposed == true)
{
throw new ObjectDisposedException(this.GetType().Name);
}
RenderModelSurface modelSurface;
lexer.ExpectTokenString("{");
// parse the name
idToken token = lexer.ExpectAnyToken();
idRenderModel model = idE.RenderModelManager.AllocateModel();
model.InitEmpty(token.ToString());
int surfaceCount = lexer.ParseInt();
int loopCount = 0;
if(surfaceCount < 0)
{
lexer.Error("ParseModel: bad surfaceCount");
}
for(int i = 0; i < surfaceCount; i++)
{
lexer.ExpectTokenString("{");
token = lexer.ExpectAnyToken();
modelSurface = new RenderModelSurface();
modelSurface.Material = idE.DeclManager.FindMaterial(token.ToString());
modelSurface.Material.AddReference();
modelSurface.Geometry = new Surface();
modelSurface.Geometry.Vertices = new Vertex[lexer.ParseInt()];
modelSurface.Geometry.Indexes = new int[lexer.ParseInt()];
loopCount = modelSurface.Geometry.Vertices.Length;
for(int j = 0; j < loopCount; j++)
{
float[] vec = lexer.Parse1DMatrix(8);
modelSurface.Geometry.Vertices[j].Position = new Vector3(vec[0], vec[1], vec[2]);
modelSurface.Geometry.Vertices[j].TextureCoordinates = new Vector2(vec[3], vec[4]);
modelSurface.Geometry.Vertices[j].Normal = new Vector3(vec[5], vec[6], vec[7]);
}
loopCount = modelSurface.Geometry.Indexes.Length;
for(int j = 0; j < loopCount; j++)
{
modelSurface.Geometry.Indexes[j] = lexer.ParseInt();
}
lexer.ExpectTokenString("}");
// add the completed surface to the model
model.AddSurface(modelSurface);
}
lexer.ExpectTokenString("}");
model.FinishSurfaces();
return model;
}
private void ParseInterAreaPortals(idLexer lexer)
{
lexer.ExpectTokenString("{");
_portalAreaCount = lexer.ParseInt();
if(_portalAreaCount < 0)
{
lexer.Error("ParseInterAreaPortals: bad portalAreaCount");
}
_portalAreas = new PortalArea[_portalAreaCount];
_areaScreenRect = new idScreenRect[_portalAreaCount];
for(int i = 0; i < _portalAreaCount; i++)
{
_portalAreas[i] = new PortalArea();
_areaScreenRect[i] = new idScreenRect();
}
// set the doubly linked lists
SetupAreaReferences();
_interAreaPortalCount = lexer.ParseInt();
if(_interAreaPortalCount < 0)
{
lexer.Error("ParseInterAreaPortals: bad interAreaPortalCount");
}
_doublePortals = new DoublePortal[_interAreaPortalCount];
for(int i = 0; i < _interAreaPortalCount; i++)
{
_doublePortals[i] = new DoublePortal();
int pointCount = lexer.ParseInt();
int a1 = lexer.ParseInt();
int a2 = lexer.ParseInt();
idWinding w = new idWinding(pointCount);
for(int j = 0; j < pointCount; j++)
{
float[] tmp = lexer.Parse1DMatrix(3);
w[j,0] = tmp[0];
w[j,1] = tmp[1];
w[j,2] = tmp[2];
// no texture coordinates
w[j,3] = 0;
w[j,4] = 0;
}
// add the portal to a1
Portal p = new Portal();
p.IntoArea = a2;
p.DoublePortal = _doublePortals[i];
p.Winding = w;
p.Plane = w.GetPlane();
p.Next = _portalAreas[a1].Portals;
_portalAreas[a1].Portals = p;
_doublePortals[i].Portals[0] = p;
// reverse it for a2
p = new Portal();
p.IntoArea = a1;
p.DoublePortal = _doublePortals[i];
p.Winding = w.Reverse();
p.Plane = w.GetPlane();
p.Next = _portalAreas[a2].Portals;
_portalAreas[a2].Portals = p;
_doublePortals[i].Portals[1] = p;
}
lexer.ExpectTokenString("}");
}
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;
}
