internal static bool MatchString(LimitChecker limitChecker, CultureInfo cultureInfo, string content, string pattern, ContentFlags flags)
{
if (!limitChecker.CheckAndIncrementContentRestrictionCount(1, content))
{
return(false);
}
CompareOptions compareOptions = RestrictionEvaluator.GetCompareOptions(flags);
ContentFlags contentFlags = flags & (ContentFlags.SubString | ContentFlags.Prefix);
CompareInfo compareInfo = cultureInfo.CompareInfo;
switch (contentFlags)
{
case ContentFlags.FullString:
return(compareInfo.Compare(content, pattern, compareOptions) == 0);
case ContentFlags.SubString:
return(compareInfo.IndexOf(content, pattern, compareOptions) != -1);
case ContentFlags.Prefix:
return(compareInfo.IsPrefix(content, pattern, compareOptions));
default:
throw new InvalidRuleException(string.Format("Not supported content flags {0}", flags));
}
}
private void FileArtifactContentDecidedInternal(FileArtifactContentDecidedEventData data)
{
m_statistics.FileArtifactContentDecidedEventCount++;
if (data.FileArtifact.IsOutputFile && data.FileContentInfo.HasKnownLength)
{
m_statistics.FileArtifactOutputWithKnownLengthCount++;
ContentFlags contentFlags = default;
switch (data.OutputOrigin)
{
case PipOutputOrigin.DeployedFromCache:
contentFlags = ContentFlags.MaterializedFromCache;
break;
case PipOutputOrigin.Produced:
contentFlags = ContentFlags.Produced;
break;
// We ignore the following cases:
// PipOutputOrigin.NotMaterialized - we cannot infer the current or future materialization status of a file
// PipOutputOrigin.UpToDate - not relevant to this analyzer
}
UpdateOrAddFile(
data.FileArtifact,
data.FileContentInfo.Length,
contentFlags,
FromContentHash(data.FileContentInfo.Hash),
data.FileArtifact.RewriteCount);
m_decidedFiles.Add(data.FileArtifact);
}
}
public override void SetContents(ContentFlags contents, int id = -1)
{
if (this.Disposed == true)
{
throw new ObjectDisposedException(this.GetType().Name);
}
}
public idClipModel(idClipModel model)
{
_id = model.ID;
_owner = model.Owner;
_enabled = model.Enabled;
_entity = model.Entity;
_origin = model.Origin;
_axis = model.Axis;
_bounds = model.Bounds;
_absBounds = model.AbsoluteBounds;
_material = model.Material;
_contents = model.Contents;
_collisionModelHandle = model.CollisionModelHandle;
_traceModelCache = null;
if (model.TraceModelCache != null)
{
idConsole.Warning("TODO: LoadModel( *GetCachedTraceModel( model->traceModelIndex ) );");
}
_renderModelHandle = model.RenderModelHandle;
_touchCount = -1;
}
private ContentFlags GetNodeContents(CollisionModelNode node)
{
ContentFlags contents = 0;
while (true)
{
foreach (CollisionModelPolygon p in node.Polygons)
{
contents |= p.Contents;
}
foreach (CollisionModelBrush b in node.Brushes)
{
contents |= b.Contents;
}
if (node.PlaneType == -1)
{
break;
}
contents |= GetNodeContents(node.Children[1]);
node = node.Children[0];
}
return(contents);
}
/// <summary>
/// Construct a DirectoryEntry with an already-encoded partial seal field.
/// </summary>
public DirectoryEntry(NameId path, PipId producerPip, ContentFlags contentFlags, uint isSharedOpaquePlusPartialSealId)
{
Path = path;
ProducerPip = producerPip;
ContentFlags = contentFlags;
IsSharedOpaquePlusPartialSealId = isSharedOpaquePlusPartialSealId;
}
/// <summary>
/// Construct a FileEntry.
/// </summary>
public FileEntry(NameId name, long sizeInBytes, PipId producerPip, ContentFlags contentFlags)
{
Path = name;
SizeInBytes = sizeInBytes;
ProducerPip = producerPip;
ContentFlags = contentFlags;
}
public static IReadOnlyList <string> GeneratextMarkup(string content, string sessionId)
{
var flags = new ContentFlags();
flags.SetMarkup();
return(GeneratePlaintextInternal(content, sessionId, flags));
}
/// <summary>
/// Construct a FileEntry.
/// </summary>
public FileEntry(NameId name, long sizeInBytes, ContentFlags contentFlags, FileHash hash, int rewriteCount)
{
Path = name;
SizeInBytes = sizeInBytes;
ContentFlags = contentFlags;
Hash = hash;
RewriteCount = rewriteCount;
}
public override void SetClipMask(ContentFlags mask, int id = -1)
{
if (this.Disposed == true)
{
throw new ObjectDisposedException(this.GetType().Name);
}
_clipMask = mask;
}
public RootHandler(BinaryReader stream)
{
while (stream.BaseStream.Position < stream.BaseStream.Length)
{
int count = stream.ReadInt32();
ContentFlags contentFlags = (ContentFlags)stream.ReadUInt32();
LocaleFlags localeFlags = (LocaleFlags)stream.ReadUInt32();
if (localeFlags == LocaleFlags.None)
{
throw new Exception("localeFlags == LocaleFlags.None");
}
if (contentFlags != ContentFlags.None && (contentFlags & (ContentFlags.F00000008 | ContentFlags.F00000010 | ContentFlags.LowViolence | ContentFlags.NoCompression | ContentFlags.F20000000)) == 0)
{
throw new Exception("contentFlags != ContentFlags.None");
}
RootEntry[] entries = new RootEntry[count];
int[] fileDataIDs = new int[count];
int fileDataIndex = 0;
for (var i = 0; i < count; ++i)
{
entries[i].LocaleFlags = localeFlags;
entries[i].ContentFlags = contentFlags;
fileDataIDs[i] = fileDataIndex + (int)stream.ReadUInt32();
fileDataIndex = fileDataIDs[i] + 1;
}
for (var i = 0; i < count; ++i)
{
entries[i].MD5 = stream.Read <MD5Hash>();
ulong hash = stream.ReadUInt64();
RootData.Add(hash, entries[i]);
ulong hash2;
int fileDataID = fileDataIDs[i];
if (FileDataStore.TryGetValue(fileDataID, out hash2))
{
if (hash2 != hash)
{
Log.Write("CASC: Hash collision for file ID {0}", fileDataID);
}
continue;
}
FileDataStore.Add(fileDataID, hash);
FileDataStoreReverse.Add(hash, fileDataID);
}
}
}
/// <summary>
/// Construct a DirectoryEntry.
/// </summary>
public DirectoryEntry(NameId path, PipId producerPip, ContentFlags contentFlags, bool isSharedOpaque, uint partialSealId)
{
Contract.Requires(!isSharedOpaque || (partialSealId > 0), "A shared opaque directory should always have a proper seal id");
Contract.Requires((partialSealId & ~PartialSealIdMask) == 0, "The most significant bit of a partial seal id should not be used");
Path = path;
ProducerPip = producerPip;
ContentFlags = contentFlags;
IsSharedOpaquePlusPartialSealId = partialSealId | (isSharedOpaque ? IsSharedOpaqueBit : 0);
}
public override string ToString()
{
return(Name.ToString() + ", " +
ParentName.ToString() + ", " +
ContentFlags.ToString() + ", " +
streamingExtentsMin.ToString() + ", " +
streamingExtentsMax.ToString() + ", " +
entitiesExtentsMin.ToString() + ", " +
entitiesExtentsMax.ToString());// + ", " +
}
public Stream OpenFile(ulong hash, string fullName, LocaleFlags locale, ContentFlags content = ContentFlags.None)
{
EncodingEntry encInfo = GetEncodingEntry(hash, locale, content);
if (encInfo != null)
{
return(OpenFile(encInfo.Keys[0]));
}
throw new FileNotFoundException(fullName);
}
/// <summary>
/// Update or add an entry for the given file path.
/// </summary>
/// <remarks>
/// If the entry already exists, its content flags will be merged with these, and the other file attributes
/// will be updated to the values passed here.
/// </remarks>
public FileId UpdateOrAdd(string filePath, long sizeInBytes, ContentFlags contentFlags, FileHash hash, int rewriteCount)
{
FileEntry entry = new FileEntry(
PathTableBuilder.GetOrAdd(filePath),
sizeInBytes,
contentFlags,
hash,
rewriteCount);
return(UpdateOrAdd(entry, m_mergeFunc));
}
public override void SetContents(ContentFlags contents, int id = -1)
{
if (this.Disposed == true)
{
throw new ObjectDisposedException(this.GetType().Name);
}
if (_clipModel != null)
{
_clipModel.Contents = contents;
}
}
private static CompareOptions GetCompareOptions(ContentFlags flags)
{
if ((flags & (ContentFlags.IgnoreNonSpace | ContentFlags.Loose)) != ContentFlags.FullString)
{
return(CompareOptions.IgnoreCase | CompareOptions.IgnoreNonSpace | CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth);
}
if ((flags & (ContentFlags.IgnoreCase | ContentFlags.Loose)) != ContentFlags.FullString)
{
return(CompareOptions.IgnoreCase | CompareOptions.IgnoreWidth);
}
return(CompareOptions.IgnoreWidth);
}
public CASCFolder SetFlags(LocaleFlags locale, ContentFlags content, bool createTree = true)
{
Locale = locale;
Content = content;
if (createTree)
{
Root = CreateStorageTree();
}
return(Root);
}
public CASCFolder SetFlags(LocaleFlags locale, ContentFlags content, bool createTree = true)
{
using (var _ = new PerfCounter(GetType().Name + "::SetFlags()"))
{
Locale = locale;
Content = content;
if (createTree)
Root = CreateStorageTree();
return Root;
}
}
public void WriteXml(StringBuilder sb, int indent)
{
CacheDatXml.StringTag(sb, indent, "name", CacheDatXml.HashString(Name));
CacheDatXml.StringTag(sb, indent, "parent", CacheDatXml.HashString(ParentName));
CacheDatXml.ValueTag(sb, indent, "contentFlags", ContentFlags.ToString());
CacheDatXml.SelfClosingTag(sb, indent, "streamingExtentsMin " + FloatUtil.GetVector3XmlString(streamingExtentsMin));
CacheDatXml.SelfClosingTag(sb, indent, "streamingExtentsMax " + FloatUtil.GetVector3XmlString(streamingExtentsMax));
CacheDatXml.SelfClosingTag(sb, indent, "entitiesExtentsMin " + FloatUtil.GetVector3XmlString(entitiesExtentsMin));
CacheDatXml.SelfClosingTag(sb, indent, "entitiesExtentsMax " + FloatUtil.GetVector3XmlString(entitiesExtentsMax));
CacheDatXml.ValueTag(sb, indent, "unk1", Unk1.ToString());
CacheDatXml.ValueTag(sb, indent, "unk2", Unk2.ToString());
CacheDatXml.ValueTag(sb, indent, "unk3", Unk3.ToString());
CacheDatXml.ValueTag(sb, indent, "unk4", Unk4.ToString());
}
private void Init()
{
if (this.Disposed == true)
{
throw new ObjectDisposedException("idClipModel");
}
_enabled = true;
_contents = ContentFlags.Body;
_renderModelHandle = -1;
_traceModelCache = null;
_touchCount = -1;
}
public CASCFolder SetFlags(LocaleFlags locale, ContentFlags content, bool createTree = true)
{
using (var _ = new PerfCounter(GetType().Name + "::SetFlags()"))
{
Locale = locale;
Content = content;
if (createTree)
{
Root = CreateStorageTree();
}
return(Root);
}
}
private bool IsBrushSolid(BspLoader bspLoader, int brushId)
{
BspBrush brush = bspLoader.Brushes[brushId];
if (brush.ShaderNum == -1)
{
return(false);
}
ContentFlags flags = bspLoader.IsVbsp
? (ContentFlags)brush.ShaderNum
: bspLoader.Shaders[brush.ShaderNum].ContentFlags;
return((flags & ContentFlags.Solid) != 0);
}
private static bool EvaluateContentRestriction(Restriction.ContentRestriction restriction, IRuleEvaluationContext context)
{
RestrictionEvaluator.ValidateContentRestriction(restriction);
PropTag propTag = restriction.PropTag;
if (restriction.MultiValued)
{
propTag = RuleUtil.GetMultiValuePropTag(propTag);
}
context.TraceFunction <PropTag, ContentFlags, object>("ContentRestriction tag [{0}] flags [{1}] value [{2}]", propTag, restriction.Flags, restriction.PropValue.Value);
object obj = context[propTag];
bool flag;
if (obj == null)
{
flag = false;
}
else if (restriction.MultiValued)
{
flag = RestrictionEvaluator.MatchMultiValueWithPattern(context, restriction.PropTag, obj, restriction.PropValue.Value, restriction.Flags);
}
else if (RuleUtil.IsTextProp(restriction.PropTag))
{
flag = RestrictionEvaluator.MatchString(context.LimitChecker, context.CultureInfo, (string)obj, (string)restriction.PropValue.Value, restriction.Flags);
}
else
{
if (!RuleUtil.IsBinaryProp(restriction.PropTag))
{
throw new InvalidRuleException(string.Format("Content restriction can't be used on tag {0}", restriction.PropTag));
}
flag = RestrictionEvaluator.MatchByteArray(context.LimitChecker, (byte[])obj, (byte[])restriction.PropValue.Value, restriction.Flags);
}
context.TraceFunction <bool, object>("ContentRestriction Evaluated to {0} with property value [{1}]", flag, obj);
if (!flag && propTag == PropTag.SenderSearchKey)
{
object obj2 = context[PropTag.SenderSmtpAddress];
if (obj2 != null)
{
string @string = CTSGlobals.AsciiEncoding.GetString((byte[])restriction.PropValue.Value);
ContentFlags contentFlags = ContentFlags.SubString | ContentFlags.IgnoreCase;
context.TraceFunction("No match found in SenderSearchKey, searching for string in SenderSmtpAddress...");
context.TraceFunction <PropTag, ContentFlags, string>("ContentRestriction tag [{0}] flags [{1}] value [{2}]", PropTag.SenderSmtpAddress, contentFlags, @string);
flag = RestrictionEvaluator.MatchString(context.LimitChecker, context.CultureInfo, (string)obj2, @string, contentFlags);
}
}
return(flag);
}
/// <summary>
/// Get or add an entry for the given file path.
/// </summary>
/// <remarks>
/// If the entry already exists, the sizeInBytes value passed here will be ignored!
/// The only time that value can be set is when adding a new file not previously recorded.
/// TODO: consider failing if this happens?
/// </remarks>
public DirectoryId GetOrAdd(
string directoryPath,
PipId producerPip,
ContentFlags contentFlags,
bool isSharedOpaque,
uint partialSealId)
{
DirectoryEntry entry = new DirectoryEntry(
PathTableBuilder.GetOrAdd(directoryPath),
producerPip,
contentFlags,
isSharedOpaque,
partialSealId);
return(GetOrAdd(entry));
}
protected void GetMatchFlagsAndOptions(ContentFlags contentFlags, out MatchFlags matchFlags, out MatchOptions matchOptions)
{
ContentFlags contentFlags2 = contentFlags & (ContentFlags)51;
switch (contentFlags2)
{
case ContentFlags.SubString:
matchOptions = MatchOptions.SubString;
break;
case ContentFlags.Prefix:
matchOptions = MatchOptions.Prefix;
break;
default:
if (contentFlags2 != ContentFlags.PrefixOnWords)
{
if (contentFlags2 != ContentFlags.ExactPhrase)
{
matchOptions = MatchOptions.FullString;
}
else
{
matchOptions = MatchOptions.ExactPhrase;
}
}
else
{
matchOptions = MatchOptions.PrefixOnWords;
}
break;
}
matchFlags = MatchFlags.Default;
if ((contentFlags & ContentFlags.IgnoreCase) != ContentFlags.FullString)
{
matchFlags |= MatchFlags.IgnoreCase;
}
if ((contentFlags & ContentFlags.IgnoreNonSpace) != ContentFlags.FullString)
{
matchFlags |= MatchFlags.IgnoreNonSpace;
}
if ((contentFlags & ContentFlags.Loose) != ContentFlags.FullString)
{
matchFlags |= MatchFlags.Loose;
}
}
private EncodingEntry GetEncodingEntryOld(ulong hash, LocaleFlags locale, ContentFlags content)
{
var rootInfos = RootHandler.GetRootInfo(hash);
foreach (var rootInfo in rootInfos)
{
if ((rootInfo.Block.LocaleFlags & locale) != 0 && (rootInfo.Block.ContentFlags & content) == 0)
{
var encInfo = EncodingHandler.GetEncodingInfo(rootInfo.MD5);
if (encInfo != null)
{
return(encInfo);
}
}
}
return(null);
}
/// <summary>
///
/// </summary>
/// <remarks>
/// an ent will be excluded from testing if:
/// cm->entity == passEntity (don't clip against the pass entity)
/// cm->entity == passOwner (missiles don't clip with owner)
/// cm->owner == passEntity (don't interact with your own missiles)
/// cm->owner == passOwner (don't interact with other missiles from same owner)
/// </remarks>
/// <param name="bounds"></param>
/// <param name="contentMask"></param>
/// <param name="passEntity"></param>
/// <returns></returns>
private idClipModel[] GetTraceClipModels(idBounds bounds, ContentFlags contentMask, idEntity passEntity)
{
idConsole.Warning("TODO: idClip.GetTraceClipModels");
// TODO
/*int i, num;
* idClipModel *cm;
* idEntity *passOwner;
*
* num = ClipModelsTouchingBounds( bounds, contentMask, clipModelList, MAX_GENTITIES );
*
* if ( !passEntity ) {
* return num;
* }
*
* if ( passEntity->GetPhysics()->GetNumClipModels() > 0 ) {
* passOwner = passEntity->GetPhysics()->GetClipModel()->GetOwner();
* } else {
* passOwner = NULL;
* }
*
* for ( i = 0; i < num; i++ ) {
*
* cm = clipModelList[i];
*
* // check if we should ignore this entity
* if ( cm->entity == passEntity ) {
* clipModelList[i] = NULL; // don't clip against the pass entity
* } else if ( cm->entity == passOwner ) {
* clipModelList[i] = NULL; // missiles don't clip with their owner
* } else if ( cm->owner ) {
* if ( cm->owner == passEntity ) {
* clipModelList[i] = NULL; // don't clip against own missiles
* } else if ( cm->owner == passOwner ) {
* clipModelList[i] = NULL; // don't clip against other missiles from same owner
* }
* }
* }
*
* return num;*/
return(null);
}
private EncodingEntry GetEncodingEntry(ulong hash, LocaleFlags locale, ContentFlags content)
{
var rootInfos = RootHandler.GetRootInfo(hash);
var rootInfosLocale = rootInfos.Where(re => (re.Block.LocaleFlags & locale) != 0);
if (rootInfosLocale.Count() > 1)
{
if (content != ContentFlags.None)
{
var rootInfosLocaleAndContent = rootInfosLocale.Where(re => (re.Block.ContentFlags & content) == 0);
if (rootInfosLocaleAndContent.Any())
{
rootInfosLocale = rootInfosLocaleAndContent;
}
}
}
return(EncodingHandler.GetEncodingInfo(rootInfosLocale.First().MD5));
}
private ContentFlags ContentsFromString(string str)
{
idLexer lexer = new idLexer();
lexer.LoadMemory(str, "ContentsFromString");
idToken token;
ContentFlags contents = ContentFlags.None;
string tmp;
while ((token = lexer.ReadToken()) != null)
{
if (token.ToString() == ",")
{
continue;
}
tmp = token.ToString();
switch (tmp)
{
case "aas_solid":
tmp = "AasSolid";
break;
case "aas_obstacle":
tmp = "AasObstacle";
break;
case "flashlight_trigger":
tmp = "FlashlightTrigger";
break;
}
contents |= (ContentFlags)Enum.Parse(typeof(ContentFlags), tmp, true);
}
return(contents);
}
public override void SetContents(ContentFlags contents, int id = -1)
{
if(this.Disposed == true)
{
throw new ObjectDisposedException(this.GetType().Name);
}
_clipModel.Contents = contents;
}
public idClipModel(idClipModel model)
{
_id = model.ID;
_owner = model.Owner;
_enabled = model.Enabled;
_entity = model.Entity;
_origin = model.Origin;
_axis = model.Axis;
_bounds = model.Bounds;
_absBounds = model.AbsoluteBounds;
_material = model.Material;
_contents = model.Contents;
_collisionModelHandle = model.CollisionModelHandle;
_traceModelCache = null;
if(model.TraceModelCache != null)
{
idConsole.Warning("TODO: LoadModel( *GetCachedTraceModel( model->traceModelIndex ) );");
}
_renderModelHandle = model.RenderModelHandle;
_touchCount = -1;
}
public CASCFolder SetFlags(LocaleFlags locale, ContentFlags content, bool createTree = true)
{
Locale = locale;
Content = content;
if (createTree)
Root = CreateStorageTree();
return Root;
}
/// <summary> /// Set the contents of a specific clip model or the whole physics object. /// </summary> /// <param name="contents"></param> /// <param name="id"></param> public abstract void SetContents(ContentFlags contents, int id = -1);
/// <summary>
/// Parses the material, if there are any errors during parsing the defaultShader will be set.
/// </summary>
/// <param name="lexer"></param>
private void ParseMaterial(idLexer lexer)
{
_registerCount = PredefinedRegisterCount; // leave space for the parms to be copied in.
for(int i = 0; i < _registerCount; i++)
{
_parsingData.RegisterIsTemporary[i] = true; // they aren't constants that can be folded.
}
TextureRepeat textureRepeatDefault = TextureRepeat.Repeat; // allow a global setting for repeat.
idToken token = null;
string tokenValue;
string tokenLower;
int count;
while(true)
{
if(TestMaterialFlag(Renderer.MaterialFlags.Defaulted) == true)
{
// we have a parse error.
return;
}
if((token = lexer.ExpectAnyToken()) == null)
{
this.MaterialFlag = MaterialFlags.Defaulted;
return;
}
tokenValue = token.ToString();
tokenLower = tokenValue.ToLower();
// end of material definition
if(tokenLower == "}")
{
break;
}
else if(tokenLower == "qer_editorimage")
{
token = lexer.ReadTokenOnLine();
_editorImageName = (token != null) ? token.ToString() : string.Empty;
lexer.SkipRestOfLine();
}
else if(tokenLower == "description")
{
token = lexer.ReadTokenOnLine();
_description = (token != null) ? token.ToString() : string.Empty;
}
// check for the surface / content bit flags.
else if(CheckSurfaceParameter(token) == true)
{
}
else if(tokenLower == "polygonoffset")
{
this.MaterialFlag = Renderer.MaterialFlags.PolygonOffset;
if((token = lexer.ReadTokenOnLine()) == null)
{
_polygonOffset = 1;
}
else
{
_polygonOffset = token.ToFloat();
}
}
// noshadow.
else if(tokenLower == "noshadows")
{
this.MaterialFlag = MaterialFlags.NoShadows;
}
else if(tokenLower == "suppressinsubview")
{
_suppressInSubview = true;
}
else if(tokenLower == "portalsky")
{
_portalSky = true;
}
else if(tokenLower == "noselfshadow")
{
this.MaterialFlag = Renderer.MaterialFlags.NoSelfShadow;
}
else if(tokenLower == "noportalfog")
{
this.MaterialFlag = Renderer.MaterialFlags.NoPortalFog;
}
// forceShadows allows nodraw surfaces to cast shadows.
else if(tokenLower == "forceshadows")
{
this.MaterialFlag = Renderer.MaterialFlags.ForceShadows;
}
// overlay / decal suppression.
else if(tokenLower == "nooverlays")
{
_allowOverlays = false;
}
// moster blood overlay forcing for alpha tested or translucent surfaces.
else if(tokenLower == "forceoverlays")
{
_parsingData.ForceOverlays = true;
}
else if(tokenLower == "translucent")
{
_coverage = MaterialCoverage.Translucent;
}
// global zero clamp.
else if(tokenLower == "zeroclamp")
{
textureRepeatDefault = TextureRepeat.ClampToZero;
}
// global clamp.
else if(tokenLower == "clamp")
{
textureRepeatDefault = TextureRepeat.Clamp;
}
// global clamp.
else if(tokenLower == "alphazeroclamp")
{
textureRepeatDefault = TextureRepeat.ClampToZero;
}
// forceOpaque is used for skies-behind-windows.
else if(tokenLower == "forceopaque")
{
_coverage = MaterialCoverage.Opaque;
}
else if(tokenLower == "twosided")
{
_cullType = CullType.TwoSided;
// twoSided implies no-shadows, because the shadow
// volume would be coplanar with the surface, giving depth fighting
// we could make this no-self-shadows, but it may be more important
// to receive shadows from no-self-shadow monsters.
this.MaterialFlag = Renderer.MaterialFlags.NoShadows;
}
else if(tokenLower == "backsided")
{
_cullType = CullType.Back;
// the shadow code doesn't handle this, so just disable shadows.
// We could fix this in the future if there was a need.
this.MaterialFlag = Renderer.MaterialFlags.NoShadows;
}
else if(tokenLower == "foglight")
{
_fogLight = true;
}
else if(tokenLower == "blendlight")
{
_blendLight = true;
}
else if(tokenLower == "ambientlight")
{
_ambientLight = true;
}
else if(tokenLower == "mirror")
{
_sort = (float) MaterialSort.Subview;
_coverage = MaterialCoverage.Opaque;
}
else if(tokenLower == "nofog")
{
_noFog = true;
}
else if(tokenLower == "unsmoothedtangents")
{
_unsmoothedTangents = true;
}
// lightFallofImage <imageprogram>
// specifies the image to use for the third axis of projected
// light volumes.
else if(tokenLower == "lightfalloffimage")
{
_lightFalloffImage = idE.ImageManager.ImageFromFile(ParsePastImageProgram(lexer), TextureFilter.Default, false, TextureRepeat.Clamp, TextureDepth.Default);
}
// guisurf <guifile> | guisurf entity
// an entity guisurf must have an idUserInterface
// specified in the renderEntity.
else if(tokenLower == "guisurf")
{
token = lexer.ReadTokenOnLine();
tokenLower = token.ToString().ToLower();
if(tokenLower == "entity")
{
_entityGui = 1;
}
else if(tokenLower == "entity2")
{
_entityGui = 2;
}
else if(tokenLower == "entity3")
{
_entityGui = 3;
}
else
{
_userInterface = idE.UIManager.FindInterface(token.ToString(), true);
}
}
// sort.
else if(tokenLower == "sort")
{
ParseSort(lexer);
}
// spectrum <integer>.
else if(tokenLower == "spectrum")
{
int.TryParse(lexer.ReadTokenOnLine().ToString(), out _spectrum);
}
// deform < sprite | tube | flare >.
else if(tokenLower == "deform")
{
ParseDeform(lexer);
}
// decalInfo <staySeconds> <fadeSeconds> (<start rgb>) (<end rgb>).
else if(tokenLower == "decalinfo")
{
ParseDecalInfo(lexer);
}
// renderbump <args...>.
else if(tokenLower == "renderbump")
{
_renderBump = lexer.ParseRestOfLine();
}
// diffusemap for stage shortcut.
else if(tokenLower == "diffusemap")
{
idLexer newLexer = new idLexer(LexerOptions.NoFatalErrors | LexerOptions.NoStringConcatination | LexerOptions.NoStringEscapeCharacters | LexerOptions.AllowPathNames);
newLexer.LoadMemory(string.Format("blend diffusemap\nmap {0}\n}}\n", ParsePastImageProgram(lexer)), "diffusemap");
ParseStage(newLexer, textureRepeatDefault);
}
// specularmap for stage shortcut.
else if(tokenLower == "specularmap")
{
idLexer newLexer = new idLexer(LexerOptions.NoFatalErrors | LexerOptions.NoStringConcatination | LexerOptions.NoStringEscapeCharacters | LexerOptions.AllowPathNames);
newLexer.LoadMemory(string.Format("blend specularmap\nmap {0}\n}}\n", ParsePastImageProgram(lexer)), "specularmap");
ParseStage(newLexer, textureRepeatDefault);
}
// normalmap for stage shortcut.
else if(tokenLower == "bumpmap")
{
idLexer newLexer = new idLexer(LexerOptions.NoFatalErrors | LexerOptions.NoStringConcatination | LexerOptions.NoStringEscapeCharacters | LexerOptions.AllowPathNames);
newLexer.LoadMemory(string.Format("blend bumpmap\nmap {0}\n}}\n", ParsePastImageProgram(lexer)), "bumpmap");
ParseStage(newLexer, textureRepeatDefault);
}
// DECAL_MACRO for backwards compatibility with the preprocessor macros.
else if(tokenLower == "decal_macro")
{
// polygonOffset
this.MaterialFlag = Renderer.MaterialFlags.PolygonOffset;
_polygonOffset = -1;
// discrete
_surfaceFlags |= SurfaceFlags.Discrete;
_contentFlags &= ~ContentFlags.Solid;
// sort decal.
_sort = (float) MaterialSort.Decal;
// noShadows
this.MaterialFlag = Renderer.MaterialFlags.NoShadows;
}
else if(tokenValue == "{")
{
// create the new stage.
ParseStage(lexer, textureRepeatDefault);
}
else
{
idConsole.WriteLine("unknown general material parameter '{0}' in '{1}'", tokenValue, this.Name);
return;
}
}
// add _flat or _white stages if needed.
AddImplicitStages();
// order the diffuse / bump / specular stages properly.
SortInteractionStages();
// if we need to do anything with normals (lighting or environment mapping)
// and two sided lighting was asked for, flag
// shouldCreateBackSides() and change culling back to single sided,
// so we get proper tangent vectors on both sides.
// we can't just call ReceivesLighting(), because the stages are still
// in temporary form.
if(_cullType == CullType.TwoSided)
{
count = _parsingData.Stages.Count;
for(int i = 0; i < count; i++)
{
if((_parsingData.Stages[i].Lighting != StageLighting.Ambient) || (_parsingData.Stages[i].Texture.TextureCoordinates != TextureCoordinateGeneration.Explicit))
{
if(_cullType == CullType.TwoSided)
{
_cullType = CullType.Front;
_shouldCreateBackSides = true;
}
break;
}
}
}
// currently a surface can only have one unique texgen for all the stages on old hardware.
TextureCoordinateGeneration firstGen = TextureCoordinateGeneration.Explicit;
count = _parsingData.Stages.Count;
for(int i = 0; i < count; i++)
{
if(_parsingData.Stages[i].Texture.TextureCoordinates != TextureCoordinateGeneration.Explicit)
{
if(firstGen == TextureCoordinateGeneration.Explicit)
{
firstGen = _parsingData.Stages[i].Texture.TextureCoordinates;
}
else if(firstGen != _parsingData.Stages[i].Texture.TextureCoordinates)
{
idConsole.Warning("material '{0}' has multiple stages with a texgen", this.Name);
break;
}
}
}
}
private void Clear()
{
_description = "<none>";
_renderBump = string.Empty;
_contentFlags = ContentFlags.Solid;
_surfaceFlags = SurfaceFlags.None;
_materialFlags = 0;
_sort = (float) MaterialSort.Bad;
_coverage = MaterialCoverage.Bad;
_cullType = CullType.Front;
_deformType = DeformType.None;
_deformRegisters = new int[4];
_ops = null;
_expressionRegisters = null;
_constantRegisters = null;
_stages = new MaterialStage[] { };
_stageCount = 0;
_ambientStageCount = 0;
_registerCount = 0;
_lightFalloffImage = null;
_entityGui = 0;
_shouldCreateBackSides = false;
_editorImageName = null;
_fogLight = false;
_blendLight = false;
_ambientLight = false;
_noFog = false;
_hasSubview = false;
_allowOverlays = true;
_unsmoothedTangents = false;
_userInterface = null;
_referenceCount = 0;
/*editorAlpha = 1.0;*/
_spectrum = 0;
_polygonOffset = 0;
_suppressInSubview = false;
_portalSky = false;
_decalInfo.StayTime = 10000;
_decalInfo.FadeTime = 4000;
_decalInfo.Start = new float[] { 1, 1, 1, 1 };
_decalInfo.End = new float[] { 0, 0, 0, 0 };
}
public MaterialInfoParameter(string name, bool clearSolid, SurfaceFlags surfaceFlags, ContentFlags contentFlags)
{
Name = name;
ClearSolid = clearSolid;
SurfaceFlags = surfaceFlags;
ContentFlags = contentFlags;
}
public override void SetClipMask(ContentFlags mask, int id = -1)
{
if(this.Disposed == true)
{
throw new ObjectDisposedException(this.GetType().Name);
}
_clipMask = mask;
}
bool HasContent (ContentFlags cf)
{
return (entry.ContentFlags & cf) == cf && WrappedType != null;
}
/// <summary>
///
/// </summary>
/// <remarks>
/// an ent will be excluded from testing if:
/// cm->entity == passEntity (don't clip against the pass entity)
/// cm->entity == passOwner (missiles don't clip with owner)
/// cm->owner == passEntity (don't interact with your own missiles)
/// cm->owner == passOwner (don't interact with other missiles from same owner)
/// </remarks>
/// <param name="bounds"></param>
/// <param name="contentMask"></param>
/// <param name="passEntity"></param>
/// <returns></returns>
private idClipModel[] GetTraceClipModels(idBounds bounds, ContentFlags contentMask, idEntity passEntity)
{
idConsole.Warning("TODO: idClip.GetTraceClipModels");
// TODO
/*int i, num;
idClipModel *cm;
idEntity *passOwner;
num = ClipModelsTouchingBounds( bounds, contentMask, clipModelList, MAX_GENTITIES );
if ( !passEntity ) {
return num;
}
if ( passEntity->GetPhysics()->GetNumClipModels() > 0 ) {
passOwner = passEntity->GetPhysics()->GetClipModel()->GetOwner();
} else {
passOwner = NULL;
}
for ( i = 0; i < num; i++ ) {
cm = clipModelList[i];
// check if we should ignore this entity
if ( cm->entity == passEntity ) {
clipModelList[i] = NULL; // don't clip against the pass entity
} else if ( cm->entity == passOwner ) {
clipModelList[i] = NULL; // missiles don't clip with their owner
} else if ( cm->owner ) {
if ( cm->owner == passEntity ) {
clipModelList[i] = NULL; // don't clip against own missiles
} else if ( cm->owner == passOwner ) {
clipModelList[i] = NULL; // don't clip against other missiles from same owner
}
}
}
return num;*/
return null;
}
/// <summary>
/// See if the current token matches one of the surface parameter bit flags.
/// </summary>
/// <param name="token"></param>
/// <returns></returns>
private bool CheckSurfaceParameter(idToken token)
{
string tokenLower = token.ToString().ToLower();
foreach(MaterialInfoParameter infoParameter in InfoParameters)
{
if(tokenLower == infoParameter.Name)
{
if((infoParameter.SurfaceFlags & Renderer.SurfaceFlags.TypeMask) == Renderer.SurfaceFlags.TypeMask)
{
// ensure we only have one surface type set
_surfaceFlags &= ~SurfaceFlags.TypeMask;
}
_surfaceFlags |= infoParameter.SurfaceFlags;
_contentFlags |= infoParameter.ContentFlags;
if(infoParameter.ClearSolid == true)
{
_contentFlags &= ~ContentFlags.Solid;
}
return true;
}
}
return false;
}
/// <summary> /// Set the contents a specific clip model or the whole physics object collides with. /// </summary> /// <param name="mask"></param> /// <param name="id"></param> public abstract void SetClipMask(ContentFlags mask, int id = -1);
/// <summary>
/// Parses the current material definition and finds all necessary images.
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public override bool Parse(string text)
{
idLexer lexer = new idLexer(idDeclFile.LexerOptions);
lexer.LoadMemory(text, this.FileName, this.LineNumber);
lexer.SkipUntilString("{");
// reset to the unparsed state.
Clear();
_parsingData = new MaterialParsingData(); // this is only valid during parsing.
// parse it
ParseMaterial(lexer);
// TODO: fs_copyFiles
// if we are doing an fs_copyfiles, also reference the editorImage
/*if ( cvarSystem->GetCVarInteger( "fs_copyFiles" ) ) {
GetEditorImage();
}*/
// count non-lit stages.
_ambientStageCount = 0;
_stageCount = _parsingData.Stages.Count;
for(int i = 0; i < _stageCount; i++)
{
if(_parsingData.Stages[i].Lighting == StageLighting.Ambient)
{
_ambientStageCount++;
}
}
// see if there is a subview stage
if(_sort == (float) MaterialSort.Subview)
{
_hasSubview = true;
}
else
{
_hasSubview = false;
int count = _parsingData.Stages.Count;
for(int i = 0; i < count; i++)
{
if(_parsingData.Stages[i].Texture.Dynamic != null)
{
_hasSubview = true;
}
}
}
// automatically determine coverage if not explicitly set.
if(_coverage == MaterialCoverage.Bad)
{
// automatically set MC_TRANSLUCENT if we don't have any interaction stages and
// the first stage is blended and not an alpha test mask or a subview.
if(_stageCount == 0)
{
// non-visible.
_coverage = MaterialCoverage.Translucent;
}
else if(_stageCount != _ambientStageCount)
{
// we have an interaction draw.
_coverage = MaterialCoverage.Opaque;
}
else
{
MaterialStates drawStateBits = _parsingData.Stages[0].DrawStateBits & MaterialStates.SourceBlendBits;
if(((drawStateBits & MaterialStates.DestinationBlendBits) != MaterialStates.DestinationBlendZero)
|| (drawStateBits == MaterialStates.SourceBlendDestinationColor)
|| (drawStateBits == MaterialStates.SourceBlendOneMinusDestinationColor)
|| (drawStateBits == MaterialStates.SourceBlendDestinationAlpha)
|| (drawStateBits == MaterialStates.SourceBlendOneMinusDestinationAlpha))
{
// blended with the destination
_coverage = MaterialCoverage.Translucent;
}
else
{
_coverage = MaterialCoverage.Opaque;
}
}
}
// translucent automatically implies noshadows.
if(_coverage == MaterialCoverage.Translucent)
{
this.MaterialFlag = MaterialFlags.NoShadows;
}
else
{
// mark the contents as opaque.
_contentFlags |= ContentFlags.Opaque;
}
// the sorts can make reasonable defaults.
if(_sort == (float) MaterialSort.Bad)
{
if(TestMaterialFlag(MaterialFlags.PolygonOffset) == true)
{
_sort = (float) MaterialSort.Decal;
}
else if(_coverage == MaterialCoverage.Translucent)
{
_sort = (float) MaterialSort.Medium;
}
else
{
_sort = (float) MaterialSort.Opaque;
}
}
// anything that references _currentRender will automatically get sort = SS_POST_PROCESS
// and coverage = MC_TRANSLUCENT.
for(int i = 0; i < _stageCount; i++)
{
MaterialStage stage = _parsingData.Stages[i];
if(stage.Texture.Image == idE.ImageManager.CurrentRenderImage)
{
if(_sort != (float) MaterialSort.PortalSky)
{
_sort = (float) MaterialSort.PostProcess;
_coverage = MaterialCoverage.Translucent;
}
break;
}
if(stage.NewStage.IsEmpty == false)
{
NewMaterialStage newShaderStage = stage.NewStage;
int imageCount = newShaderStage.FragmentProgramImages.Length;
for(int j = 0; j < imageCount; j++)
{
if(newShaderStage.FragmentProgramImages[j] == idE.ImageManager.CurrentRenderImage)
{
if(_sort != (float) MaterialSort.PortalSky)
{
_sort = (float) MaterialSort.PostProcess;
_coverage = MaterialCoverage.Translucent;
}
i = _stageCount;
break;
}
}
}
}
// set the drawStateBits depth flags.
for(int i = 0; i < _stageCount; i++)
{
MaterialStage stage = _parsingData.Stages[i];
if(_sort == (float) MaterialSort.PostProcess)
{
// post-process effects fill the depth buffer as they draw, so only the
// topmost post-process effect is rendered.
stage.DrawStateBits |= MaterialStates.DepthFunctionLess;
}
else if((_coverage == MaterialCoverage.Translucent) || (stage.IgnoreAlphaTest == true))
{
// translucent surfaces can extend past the exactly marked depth buffer.
stage.DrawStateBits |= MaterialStates.DepthFunctionLess | MaterialStates.DepthMask;
}
else
{
// opaque and perforated surfaces must exactly match the depth buffer,
// which gets alpha test correct.
stage.DrawStateBits |= MaterialStates.DepthFunctionEqual | MaterialStates.DepthMask;
}
_parsingData.Stages[i] = stage;
}
// determine if this surface will accept overlays / decals.
if(_parsingData.ForceOverlays == true)
{
// explicitly flaged in material definition
_allowOverlays = true;
}
else
{
if(this.IsDrawn == false)
{
_allowOverlays = false;
}
if(this.Coverage != MaterialCoverage.Opaque)
{
_allowOverlays = false;
}
if((this.SurfaceFlags & Renderer.SurfaceFlags.NoImpact) == Renderer.SurfaceFlags.NoImpact)
{
_allowOverlays = false;
}
}
// add a tiny offset to the sort orders, so that different materials
// that have the same sort value will at least sort consistantly, instead
// of flickering back and forth.
/* this messed up in-game guis
if ( sort != SS_SUBVIEW ) {
int hash, l;
l = name.Length();
hash = 0;
for ( int i = 0 ; i < l ; i++ ) {
hash ^= name[i];
}
sort += hash * 0.01;
}
*/
if(_stageCount > 0)
{
_stages = _parsingData.Stages.ToArray();
}
if(_parsingData.Operations.Count > 0)
{
_ops = _parsingData.Operations.ToArray();
}
if(_registerCount > 0)
{
_expressionRegisters = new float[_registerCount];
Array.Copy(_parsingData.ShaderRegisters, _expressionRegisters, _registerCount);
}
// see if the registers are completely constant, and don't need to be evaluated per-surface.
CheckForConstantRegisters();
_parsingData = null;
// finish things up
if(TestMaterialFlag(MaterialFlags.Defaulted) == true)
{
MakeDefault();
return false;
}
return true;
}
public ContentFlags ContentsModel(Vector3 start, idClipModel model, Matrix traceModelAxis, ContentFlags contentMask, object modelHandle, Vector3 modelOrigin, Matrix modelAxis)
{
idConsole.Warning("TODO: idClip.ContentsModel");
_contentCount++;
// TODO: NEED ENGINE SOURCE return idR.CollisionModelManager.Contents(start, TraceModelForClipModel(model), traceModelAxis, contentMask, modelHandle, modelOrigin, modelAxis);
return ContentFlags.None;
}
private void Init()
{
if(this.Disposed == true)
{
throw new ObjectDisposedException("idClipModel");
}
_enabled = true;
_contents = ContentFlags.Body;
_renderModelHandle = -1;
_traceModelCache = null;
_touchCount = -1;
}
public bool Translation(out TraceResult result, Vector3 start, Vector3 end, idClipModel model, Matrix traceModelAxis, ContentFlags contentMask, idEntity passEntity)
{
idConsole.Warning("TODO: idClip.Translation");
// TODO
/*if(TestHugeTranslation(result, model, start, end, traceModelAxis) == true)
{
return true;
}*/
// TODO
/*idTraceModel traceModel = TraceModelForClipModel(model);
idBounds traceBounds = new idBounds();
TraceResult traceResult;
float radius = 0;
if((passEntity == null) || (passEntity.Index != idR.EntityIndexWorld))
{
// test world
_translationCount++;
// TODO: idR.CollisionModelManager.Translation(out result, start, end, traceModel, traceModelAxis, contentMask, 0, Vector3.Zero, Matrix.Identity);
result.ContactInformation.EntityIndex = (result.Fraction != 1.0f) ? idR.EntityIndexWorld : idR.EntityIndexNone;
if(result.Fraction == 0.0f)
{
return true; // blocked immediately by the world
}
}
else
{
result = new TraceResult();
result.Fraction = 1.0f;
result.EndPosition = end;
result.EndAxis = traceModelAxis;
}
if(traceModel == null)
{
traceBounds = idBounds.FromPointTranslation(start, result.EndPosition - start);
radius = 0.0f;
}
else
{
traceBounds = idBounds.FromBoundsTranslation(traceModel.Bounds, start, traceModelAxis, result.EndPosition - start);
radius = traceModel.Bounds.GetRadius();
}
idClipModel[] clipModelList = GetTraceClipModels(traceBounds, contentMask, passEntity);
foreach(idClipModel touch in clipModelList)
{
if(touch == null)
{
continue;
}
if(touch.RenderModelHandle != -1)
{
_renderModelTraceCount++;
traceResult = TraceRenderModel(start, end, radius, traceModelAxis, touch);
}
else
{
_translationCount++;
// TODO: traceResult = idR.CollisionModelManager.Translation(start, end, traceModel, traceModelAxis, contentMask, touch.Handle, touch.Origin, touch.Axis);
}
if(traceResult.Fraction < result.Fraction)
{
result = traceResult;
result.ContactInformation.EntityIndex = touch.Entity.Index;
result.ContactInformation.ID = touch.ID;
if(result.Fraction == 0.0f)
{
break;
}
}
}
return (result.Fraction < 1.0f);*/
result = new TraceResult();
return false;
}
public TraceResult RotationModel(Vector3 start, idRotation rotation, idClipModel model, Matrix traceModelAxis, ContentFlags contentMask, int modelHandle, Vector3 modelOrigin, Matrix modelAxis)
{
idConsole.Warning("TODO: idClip.RotationModel");
// TODO: idTraceModel traceModel = TraceModelForClipModel(model);
_rotationCount++;
// TODO: return idR.CollisionModelManager.Rotation(start, rotation, traceModel, traceModelAxis, contentMask, modelHandle, modelOrigin, modelAxis);
return new TraceResult();
}
void UpdateContent (IType cls)
{
Name = cls.Name;
ctype = cls.ClassType;
modifiers = cls.Modifiers;
typeModifier = cls.TypeModifier;
this.typeParameterCount = cls.TypeParameters.Count;
flags = (ContentFlags) 0;
if (this.typeParameterCount > 0)
flags |= ContentFlags.HasGenericParams;
if (cls.Attributes.Count () > 0)
flags |= ContentFlags.HasAttributes;
if ((cls.BaseType != null && !cls.BaseType.ToInvariantString ().Equals (DomReturnType.Object.ToInvariantString ())) || cls.ImplementedInterfaces.Count () > 0)
flags |= ContentFlags.HasBaseTypes;
if (cls.CompilationUnit != null)
flags |= ContentFlags.HasCompilationUnit;
if (cls.Documentation != null && cls.Documentation.Length > 0)
flags |= ContentFlags.HasDocumentation;
if (cls.EventCount > 0)
flags |= ContentFlags.HasEvents;
if (cls.FieldCount > 0)
flags |= ContentFlags.HasFields;
if (cls.IndexerCount > 0)
flags |= ContentFlags.HasIndexers;
if (cls.InnerTypeCount > 0)
flags |= ContentFlags.HasInnerClasses;
if (cls.MethodCount > 0)
flags |= ContentFlags.HasMethods;
if (cls.PropertyCount > 0)
flags |= ContentFlags.HasProperties;
if (cls.HasParts)
flags |= ContentFlags.HasParts;
if (cls.Location != DomLocation.Empty)
flags |= ContentFlags.HasRegion;
if (cls.BodyRegion != DomRegion.Empty)
flags |= ContentFlags.HasBodyRegion;
if (cls.ConstructorCount > 0)
flags |= ContentFlags.HasConstructors;
if (cls.IsObsolete)
flags |= ContentFlags.IsObsolete;
if (cls.HasExtensionMethods)
flags |= ContentFlags.HasExtensionMethods;
}
public bool Rotation(out TraceResult result, Vector3 start, idRotation rotation, idClipModel model, Matrix traceModelAxis, ContentFlags contentMask, idEntity passEntity)
{
idConsole.Warning("TODO: idClip.Rotation");
/*idTraceModel traceModel = TraceModelForClipModel(model);
idBounds traceBounds = new idBounds();
TraceResult traceResult;
if((passEntity == null) || (passEntity.Index != idR.EntityIndexWorld))
{
// test world
_rotationCount++;
// TODO: NEED ENGINE SOURCE idR.CollisionModelManager.Rotation(out result, start, rotation, traceModel, traceModelAxis, contentMask, 0, Vector3.Zero, Matrix.Identity);
result.ContactInformation.EntityIndex = (result.Fraction != 1.0f) ? idR.EntityIndexWorld : idR.EntityIndexNone;
if(result.Fraction == 0.0f)
{
return true; // blocked immediately by the world
}
}
else
{
result = new TraceResult();
result.Fraction = 1.0f;
result.EndPosition = start;
result.EndAxis = traceModelAxis * rotation.ToMatrix();
}
if(traceModel == null)
{
traceBounds = idBounds.FromPointRotation(start, rotation);
}
else
{
traceBounds = idBounds.FromBoundsRotation(traceModel.Bounds, start, traceModelAxis, rotation);
}
idClipModel[] clipModelList = GetTraceClipModels(traceBounds, contentMask, passEntity);
foreach(idClipModel touch in clipModelList)
{
if(touch == null)
{
continue;
}
if(touch.RenderModelHandle != -1)
{
continue;
}
_rotationCount++;
// TODO: traceResult = idR.CollisionModelManager.Rotation(start, rotation, traceModel, traceModelAxis, contentMask, touch.Handle, touch.Origin, touch.Axis);
if(traceResult.Fraction < result.Fraction)
{
result = traceResult;
result.ContactInformation.EntityIndex = touch.Entity.Index;
result.ContactInformation.ID = touch.ID;
if(result.Fraction == 0.0f)
{
break;
}
}
}
return (result.Fraction < 1.0f);*/
result = new TraceResult();
return false;
}
static void Main(string[] args)
{
if (args.Length != 4)
{
Console.WriteLine("Invalid arguments count!");
Console.WriteLine("Usage: CASCConsole <pattern> <destination> <localeFlags> <contentFlags>");
return;
}
Console.WriteLine("Settings:");
Console.WriteLine(" WowPath: {0}", Settings.Default.StoragePath);
Console.WriteLine(" OnlineMode: {0}", Settings.Default.OnlineMode);
Console.WriteLine("Loading...");
BackgroundWorkerEx bgLoader = new BackgroundWorkerEx();
bgLoader.ProgressChanged += BgLoader_ProgressChanged;
CASCConfig config = Settings.Default.OnlineMode
? CASCConfig.LoadOnlineStorageConfig(Settings.Default.Product, "us")
: CASCConfig.LoadLocalStorageConfig(Settings.Default.StoragePath);
CASCHandler cascHandler = CASCHandler.OpenStorage(config, bgLoader);
string pattern = args[0];
string dest = args[1];
LocaleFlags locale = (LocaleFlags)Enum.Parse(typeof(LocaleFlags), args[2]);
ContentFlags content = (ContentFlags)Enum.Parse(typeof(ContentFlags), args[3]);
cascHandler.Root.LoadListFile(Path.Combine(Environment.CurrentDirectory, "listfile.txt"), bgLoader);
CASCFolder root = cascHandler.Root.SetFlags(locale, content);
Console.WriteLine("Loaded.");
Console.WriteLine("Extract params:", pattern, dest, locale);
Console.WriteLine(" Pattern: {0}", pattern);
Console.WriteLine(" Destination: {0}", dest);
Console.WriteLine(" LocaleFlags: {0}", locale);
Console.WriteLine(" ContentFlags: {0}", content);
Wildcard wildcard = new Wildcard(pattern, true, RegexOptions.IgnoreCase);
foreach (var file in root.GetFiles())
{
if (wildcard.IsMatch(file.FullName))
{
Console.Write("Extracting '{0}'...", file.FullName);
try
{
cascHandler.SaveFileTo(file.FullName, dest);
Console.WriteLine(" Ok!");
}
catch (Exception exc)
{
Console.WriteLine(" Error!");
Logger.WriteLine(exc.Message);
}
}
}
Console.WriteLine("Extracted.");
}
public ContentFlags Contents(Vector3 start, idClipModel model, Matrix traceModelAxis, ContentFlags contentMask, idEntity passEntity)
{
idConsole.Warning("TODO: idClip.Contents");
ContentFlags contents = ContentFlags.None;
idBounds traceModelBounds = new idBounds();
// TODO
/*idTraceModel traceModel = TraceModelForClipModel(model);
if((passEntity == null) || (passEntity.Index != idR.EntityIndexWorld))
{
// test world
_contentCount++;
// TODO: NEED ENGINE SOURCE contents = idR.CollisionModelManager.Contents(start, traceModel, traceModelAxis, contentMask, 0, Vector3.Zero, Matrix.Identity);
}
else
{
contents = ContentFlags.None;
}
if(traceModel == null)
{
traceModelBounds.Min = start;
traceModelBounds.Max = start;
}
else if(traceModelAxis != Matrix.Identity)
{
traceModelBounds = idBounds.FromTransformedBounds(traceModel.Bounds, start, traceModelAxis);
}
else
{
traceModelBounds.Min = traceModel.Bounds.Min + start;
traceModelBounds.Max = traceModel.Bounds.Max + start;
}
idClipModel[] traceModelList = GetTraceClipModels(traceModelBounds, -1, passEntity);
foreach(idClipModel touch in traceModelList)
{
if(touch == null)
{
continue;
}
// no contents test with render models
if(touch.RenderModelHandle != -1)
{
continue;
}
// if the entity does not have any contents we are looking for
if((touch.Contents & contentMask) == ContentFlags.None)
{
continue;
}
// if the entity has no new contents flags
if((touch.Contents & contents) == touch.Contents)
{
continue;
}
_contentCount++;
// TODO
/*if(idR.CollisionModelManager.Contents(start, traceModel, traceModelAxis, contentMask, touch.Handle, touch.Origin, touch.Axis) > 0)
{
contents |= (touch.Contents & contentMask);
}*/
/*}*/
return contents;
}
