public scenario_structure_bsp(CacheBase Cache, CacheBase.IndexItem Tag)
{
cache = Cache;
int Address = Tag.Offset;
EndianReader Reader = Cache.Reader;
Reader.SeekTo(Address);
Reader.SeekTo(Address + 68);
XBounds = new Range <float>(Reader.ReadSingle(), Reader.ReadSingle());
YBounds = new Range <float>(Reader.ReadSingle(), Reader.ReadSingle());
ZBounds = new Range <float>(Reader.ReadSingle(), Reader.ReadSingle());
#region Clusters Block
Reader.SeekTo(Address + 172);
int iCount = Reader.ReadInt32();
int iOffset = Reader.ReadInt32() - Tag.Magic;
for (int i = 0; i < iCount; i++)
{
ModelSections.Add(new ModelSection(Cache, Tag, iOffset + 176 * i, null)
{
FacesIndex = i, VertsIndex = i, NodeIndex = 255
});
Clusters.Add(new Cluster(i));
}
#endregion
#region Shaders Block
Reader.SeekTo(Address + 180);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Tag.Magic;
for (int i = 0; i < iCount; i++)
{
Shaders.Add(new Halo2Xbox.render_model.Shader(Cache, iOffset + 32 * i));
}
#endregion
#region ModelParts Block
Reader.SeekTo(Address + 328);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Tag.Magic;
for (int i = 0; i < iCount; i++)
{
ModelSections.Add(new ModelSection(Cache, Tag, iOffset + 200 * i, BoundingBoxes)
{
FacesIndex = i + Clusters.Count, VertsIndex = i + Clusters.Count, NodeIndex = 255
});
}
#endregion
#region GeometryInstances Block
Reader.SeekTo(Address + 336);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Tag.Magic;
for (int i = 0; i < iCount; i++)
{
GeomInstances.Add(new InstancedGeometry(Cache, iOffset + 88 * i, Clusters.Count));
}
#endregion
}
/// <summary />
public ShaderLibrary(RenderHost renderHost)
{
Shaders.Add(ShaderDefault = new Default.Shader(renderHost));
Shaders.Add(ShaderPosition = new Position.Shader(renderHost));
Shaders.Add(ShaderPositionColor = new PositionColor.Shader(renderHost));
Shaders.Add(ShaderPositionTexture = new PositionTexture.Shader(renderHost));
}
protected VertexArray(int vertexArrayId, VertexBuffer vertexBuffer, ShaderProgram shader, Texture texture, ElementBuffer elementBuffer, params VertexAttribute[] vertexAttributes) : this(vertexArrayId, vertexBuffer)
{
Shaders.Add(shader);
Textures.Add(texture);
ElementBuffer = elementBuffer;
_vertexAttributes.AddRange(vertexAttributes);
}
/// <summary>
/// GetShader loads a shader resource from disk
/// </summary>
private RhGLShaderProgram GetShader(string baseName)
{
for (int i = 0; i < Shaders.Count; i++)
{
var shader = Shaders [i];
if (shader.Name.Equals(baseName, StringComparison.InvariantCultureIgnoreCase))
{
SetupShader(shader, Model, Viewport);
return(shader);
}
}
String vertex_shader = GetResourceAsString(baseName, "vsh");
String fragment_shader = GetResourceAsString(baseName, "fsh");
var new_shader = RhGLShaderProgram.BuildProgram(baseName, vertex_shader, fragment_shader);
if (new_shader != null)
{
Shaders.Add(new_shader);
}
SetupShader(new_shader, Model, Viewport);
return(new_shader);
}
public void LoadShaders()
{
BasicEffect BasicEffect = new BasicEffect(Graphics);
Shaders.Add("Default", BasicEffect);
DirectoryInfo Folder = new DirectoryInfo(ShaderLocation);
if (Folder.Exists)
{
FileInfo[] ConfigFiles = Folder.GetFiles();
foreach (FileInfo CurrentFile in ConfigFiles)
{
if (CurrentFile.Extension.Equals(".mgfxo"))
{
string Name = CurrentFile.Name.Remove(CurrentFile.Name.Length - 6, 6);
Effect Test = new Effect(Graphics, File.ReadAllBytes(CurrentFile.FullName.ToString()));
Test.Name = Name;
Shaders.Add(Name, Test);
}
}
}
}
public void LoadFormatsFile(string filePath)
{
FormatsFile file = new FormatsFile(filePath);
var versionNode = file.Root.Properties.FirstOrDefault(n => n.Name == "Version");
if (!Formats.CheckVersion(versionNode, Type, Version))
{
return;
}
var shadersNode = versionNode.Properties.FirstOrDefault(n => n.Name == "Shaders");
if (shadersNode != null)
{
foreach (var shaderNode in shadersNode.Properties)
{
Shader shader = new Shader();
shader.LoadFormatsNode(shaderNode);
Shaders.Add(shader);
}
}
var skeletonNode = versionNode.Properties.FirstOrDefault(n => n.Name == "Skeleton");
if (skeletonNode != null && skeletonNode.Value != "null")
{
/*
* Skeleton = new Skeleton();
* Skeleton.LoadFormatsFile(Path.Combine(Path.GetDirectoryName(file.FileName), skeletonNode.Value));
*/
}
var lodGroupNode = versionNode.Properties.FirstOrDefault(n => n.Name == "LodGroup");
if (lodGroupNode != null)
{
LodGroup = new LodGroup();
LodGroup.LoadFormatsNode(lodGroupNode);
}
var jointsNode = versionNode.Properties.FirstOrDefault(n => n.Name == "Joints");
if (jointsNode != null && jointsNode.Value != "null")
{
}
var lightNode = versionNode.Properties.FirstOrDefault(n => n.Name == "Light");
if (lightNode != null && lightNode.Value != "null")
{
}
var boundNode = versionNode.Properties.FirstOrDefault(n => n.Name == "Bound");
if (boundNode != null && boundNode.Value != "null")
{
}
}
public void AddShader(string pass, Shader shader)
{
if (!Shaders.ContainsKey(pass))
{
Shaders.Add(pass, new List <Shader>());
}
Shaders[pass].Add(shader);
}
public scenario_structure_bsp(CacheBase Cache, CacheBase.IndexItem Tag)
{
cache = Cache;
int Address = Tag.Offset;
EndianReader Reader = Cache.Reader;
Reader.SeekTo(Address + 0xE0);
XBounds = new Range <float>(Reader.ReadSingle(), Reader.ReadSingle());
YBounds = new Range <float>(Reader.ReadSingle(), Reader.ReadSingle());
ZBounds = new Range <float>(Reader.ReadSingle(), Reader.ReadSingle());
Reader.SeekTo(Address + 0x110);
indexCount = Reader.ReadInt32() * 3;
indexOffset = Reader.ReadInt32() - Tag.Magic;
#region Lightmaps Block
Reader.SeekTo(Address + 0x11C);
int iCount = Reader.ReadInt32();
int iOffset = Reader.ReadInt32() - Tag.Magic;
for (int i = 0; i < iCount; i++)
{
ModelSections.Add(new Lightmap(cache, iOffset + 32 * i, Tag.Magic)
{
VertsIndex = i, FacesIndex = i, NodeIndex = 255
});
}
#endregion
#region Create Shader List
var sIDs = new List <int>();
for (int i = 0; i < ModelSections.Count; i++)
{
var section = ModelSections[i];
for (int j = 0; j < section.Submeshes.Count; j++)
{
var mesh = (Lightmap.Material)section.Submeshes[j];
if (!sIDs.Contains(mesh.shaderID))
{
sIDs.Add(mesh.shaderID);
}
mesh.ShaderIndex = sIDs.IndexOf(mesh.shaderID);
}
}
foreach (int ID in sIDs)
{
Shaders.Add(new Shader(ID));
}
for (int i = 0; i < ModelSections.Count; i++)
{
Clusters.Add(new Cluster(i));
}
#endregion
}
public void InitByMgr(BaseSurfaceMgr mgr, string matName = "", bool isInstance = true)
{
IsInstance = isInstance;
SurfaceMgr = mgr;
SourceMats.Clear();
SourceMatsArray.Clear();
Shaders.Clear();
var renders = GetRenderers();
if (renders != null)
{
for (int i = 0; i < renders.Length; ++i)
{
GetMaterial(renders[i], out Material material);
SourceMats.Add(renders[i], material);
}
for (int i = 0; i < renders.Length; ++i)
{
GetMaterials(renders[i], out Material[] materials);
SourceMatsArray.Add(renders[i], materials);
if (materials != null)
{
foreach (var item in materials)
{
if (!Shaders.Contains(item.shader))
{
Shaders.Add(item.shader);
}
}
}
}
//获得材质
string tempMatName = matName.IsInv() ? GetDefaultMatName() : matName;
if (UsedMaterials.Count == 0 && !tempMatName.IsInv())
{
foreach (var key in Shaders)
{
var mat = GRMgr.Material.Spawn(tempMatName);
if (DefaultUsedMaterial == null)
{
DefaultUsedMaterial = mat;
}
UsedMaterials.Add(key, mat);
}
}
}
OnInit();
}
private void AddShader(Shader shader)
{
if (shader == null)
{
throw new ArgumentNullException("shader");
}
if (Shaders.ContainsKey(shader.Type))
{
throw new InvalidOperationException($"ShaderProgram.AddShader ({Name}): Program already contains a shader of type {shader.Type.ToString()}");
}
Shaders.Add(shader.Type, shader);
}
/// <summary>
/// Gets a shader specified by name. Creates new one if it doesn't exist.
/// </summary>
/// <param name="name">Name of the shader (with .*)</param>
/// <returns></returns>
public static ShaderProgram GetOrCreateShader(string name)
{
ShaderProgram sp = null;
Shaders.TryGetValue(name, out sp);
if (sp == null)
{
Console.WriteLine("Creating Shader " + name);
sp = new ShaderProgram(name);
Shaders.Add(name, sp);
}
return(sp);
}
private void MakeShader(ShaderType type, string source)
{
if (source == null)
{
return;
}
var shader = new ShaderRL(type);
shader.Load(source);
Shaders.Add(shader);
RL.AttachShader(ProgramObject, shader.ShaderObject);
}
public SurfaceManager()
{
Shaders.Add(
ShaderFileLoader.CreateDefault(asset("Shaders/")).Load(".")
);
new[]
{
"geometry", "uvcolor",
"Deferred/gSprite",
"Deferred/gLevel",
"Deferred/debug",
"Deferred/compose",
"Deferred/pointlight"
}.ForEach(name => Shaders.MakeShaderProgram(name));
Primitives = new IndexedSurface <PrimitiveVertexData>()
.WithShader(Shaders["geometry"])
.AndSettings(ViewMatrix, ProjectionMatrix);
ConsoleBackground = new IndexedSurface <PrimitiveVertexData>()
.WithShader(Shaders["geometry"])
.AndSettings(ViewMatrix, ProjectionMatrix);
ConsoleFont = Font.FromJsonFile(font("Inconsolata.json"));
ConsoleFontSurface = new IndexedSurface <UVColorVertexData>()
.WithShader(Shaders["uvcolor"])
.AndSettings(
ViewMatrix, ProjectionMatrix,
new TextureUniform("diffuse", new Texture(font("Inconsolata.png"), preMultiplyAlpha: true))
);
UIFont = Font.FromJsonFile(font("HelveticaNeue.json"));
UIFontSurface = new IndexedSurface <UVColorVertexData>()
.WithShader(Shaders["uvcolor"])
.AndSettings(
ViewMatrix, ProjectionMatrix,
new TextureUniform("diffuse", new Texture(font("HelveticaNeue.png"), preMultiplyAlpha: true))
);
LevelSurface = new IndexedSurface <LevelVertex>()
.WithShader(Shaders["Deferred/gLevel"])
.AndSettings(ViewMatrix, ProjectionMatrix);
PointLights = new IndexedSurface <PointLightVertex>()
.WithShader(Shaders["Deferred/pointlight"])
.AndSettings(ViewMatrix, ProjectionMatrix);
GameSurfaces = new GameSurfaceManager(Shaders, ViewMatrix, ProjectionMatrix);
}
public bool TryAddShader(Shader shader)
{
if ((shader == null) || string.IsNullOrEmpty(shader.Name) || Shaders.ContainsKey(shader.Name))
{
return(false);
}
if (string.IsNullOrEmpty(shader.Material) || !Materials.ContainsKey(shader.Material))
{
return(false);
}
if (!string.IsNullOrEmpty(shader.Texture) && !Textures.ContainsKey(shader.Texture))
{
return(false);
}
Shaders.Add(shader.Name, shader);
return(true);
}
private void MakeShaderFromFile(ShaderType type, string fullpath)
{
if (fullpath == null)
{
return;
}
var shader = new ShaderRL(type);
shader.LoadFromFile(fullpath);
#if ASSET_MONITOR
shader.AddProgram(this);
#endif
Shaders.Add(shader);
RL.AttachShader(ProgramObject, shader.ShaderObject);
}
static public void LoadShader(string assetName)
{
ShaderAsset SA = AssetsManagerInstance.GetManager().LoadAsset <ShaderAsset>(assetName);
Debug.Log("AssetManager", SA.ShaderType.ToString() + " Shader " + assetName + " loaded. ");
ShaderPlusSignature pack = new ShaderPlusSignature();
ShaderBytecode sb = new ShaderBytecode(SA.Bytecode);
switch (SA.ShaderType)
{
case ShaderTypeEnum.Vertex:
pack.shader = new VertexShader(RenderBackend.Device, sb);
break;
case ShaderTypeEnum.Pixel:
pack.shader = new PixelShader(RenderBackend.Device, sb);
break;
case ShaderTypeEnum.Geometry:
pack.shader = new GeometryShader(RenderBackend.Device, sb);
break;
case ShaderTypeEnum.Compute:
pack.shader = new ComputeShader(RenderBackend.Device, sb);
break;
case ShaderTypeEnum.Hull:
pack.shader = new HullShader(RenderBackend.Device, sb);
break;
case ShaderTypeEnum.Domain:
pack.shader = new DomainShader(RenderBackend.Device, sb);
break;
default:
break;
}
;
SA = null;
pack.shader.DebugName = assetName;
pack.signature = ShaderSignature.GetInputSignature(sb);
Shaders.Add(assetName, pack);
}
public render_model(CacheBase Cache, int Address)
{
cache = Cache;
EndianReader Reader = Cache.Reader;
Reader.SeekTo(Address);
Name = Cache.Strings.GetItemByID(Reader.ReadInt32());
Flags = new Bitmask(Reader.ReadInt32());
#region Regions Block
Reader.SeekTo(Address + 12);
int iCount = Reader.ReadInt32();
int iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
Regions.Add(new Region(Cache, iOffset + 16 * i));
}
#endregion
Reader.SeekTo(Address + 28);
InstancedGeometryIndex = Reader.ReadInt32();
#region Instanced Geometry Block
Reader.SeekTo(Address + 32);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
GeomInstances.Add(new InstancedGeometry(Cache, iOffset + 60 * i));
}
#endregion
#region Nodes Block
Reader.SeekTo(Address + 48);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
Nodes.Add(new Node(Cache, iOffset + 96 * i));
}
#endregion
#region MarkerGroups Block
Reader.SeekTo(Address + 60);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
MarkerGroups.Add(new MarkerGroup(Cache, iOffset + 16 * i));
}
#endregion
#region Shaders Block
Reader.SeekTo(Address + 72);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
Shaders.Add(new Shader(Cache, iOffset + 44 * i));
}
#endregion
#region ModelSections Block
Reader.SeekTo(Address + 104);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
ModelSections.Add(new ModelSection(Cache, iOffset + 92 * i));
}
#endregion
#region BoundingBox Block
Reader.SeekTo(Address + 116);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
BoundingBoxes.Add(new BoundingBox(Cache, iOffset + 52 * i));
}
#endregion
#region NodeMapGroup Block
Reader.SeekTo(Address + 176);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
NodeIndexGroups.Add(new NodeIndexGroup(Cache, iOffset + 12 * i));
}
#endregion
Reader.SeekTo(Address + 236);
RawID = Reader.ReadInt32();
}
public gbxmodel(CacheBase Cache, int Address)
{
cache = Cache;
EndianReader Reader = Cache.Reader;
Reader.SeekTo(Address);
Name = "gbxmodel";
Flags = new Bitmask(Reader.ReadInt16());
Reader.SeekTo(Address + 0x30);
uScale = Reader.ReadSingle();
vScale = Reader.ReadSingle();
#region MarkerGroups Block
Reader.SeekTo(Address + 0xAC);
int iCount = Reader.ReadInt32();
int iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
MarkerGroups.Add(new MarkerGroup(Cache, iOffset + 64 * i));
}
#endregion
#region Nodes Block
Reader.SeekTo(Address + 0xB8);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
Nodes.Add(new Node(Cache, iOffset + 156 * i));
}
#endregion
#region Regions Block
Reader.SeekTo(Address + 0xC4);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
Regions.Add(new Region(Cache, iOffset + 76 * i));
}
#endregion
#region ModelParts Block
Reader.SeekTo(Address + 0xD0);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
ModelSections.Add(new ModelSection(Cache, iOffset + 48 * i)
{
FacesIndex = i, VertsIndex = i, NodeIndex = 255
});
}
#endregion
#region Shaders Block
Reader.SeekTo(Address + 0xDC);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
Shaders.Add(new Shader(Cache, iOffset + 32 * i));
}
#endregion
#region BoundingBox Block
BoundingBoxes.Add(new BoundingBox());
#endregion
}
private d3dx_state CreateShader(TwoMGFX.ShaderInfo shaderInfo, string shaderFunction, string shaderProfile, bool isVertexShader)
{
// Compile the shader.
SharpDX.D3DCompiler.ShaderBytecode shaderByteCode;
try
{
SharpDX.D3DCompiler.ShaderFlags shaderFlags = 0;
// While we never allow preshaders, this flag is invalid for
// the DX11 shader compiler which doesn't allow preshaders
// in the first place.
//shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.NoPreshader;
if (shaderInfo.DX11Profile)
{
shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.EnableBackwardsCompatibility;
}
if (shaderInfo.Debug)
{
shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.SkipOptimization;
shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.Debug;
}
else
{
shaderFlags |= SharpDX.D3DCompiler.ShaderFlags.OptimizationLevel3;
}
// Compile the shader into bytecode.
var result = SharpDX.D3DCompiler.ShaderBytecode.Compile(
shaderInfo.fileContent,
shaderFunction,
shaderProfile,
shaderFlags,
0,
null,
null,
shaderInfo.fileName);
if (result.HasErrors)
{
throw new Exception(result.Message);
}
shaderByteCode = result.Bytecode;
//var source = shaderByteCode.Disassemble();
}
catch (Exception ex)
{
throw ex;
}
// Get a copy of the shader bytecode.
var bytecode = shaderByteCode.Data.ToArray();
// First look to see if we already created this same shader.
DXShaderData dxShader = null;
foreach (var shader in Shaders)
{
if (bytecode.SequenceEqual(shader.Bytecode))
{
dxShader = shader;
break;
}
}
// Create a new shader.
if (dxShader == null)
{
if (shaderInfo.DX11Profile)
{
dxShader = DXShaderData.CreateHLSL(bytecode, isVertexShader, ConstantBuffers, Shaders.Count, shaderInfo.Debug);
}
else
{
dxShader = DXShaderData.CreateGLSL(bytecode, ConstantBuffers, Shaders.Count);
}
Shaders.Add(dxShader);
}
//var assmbly = desc.Bytecode.Disassemble();
//var buffer = reflection.GetConstantBuffer(0);
var state = new d3dx_state();
state.index = 0;
state.type = STATE_TYPE.CONSTANT;
state.operation = isVertexShader ? (uint)146 : (uint)147;
state.parameter = new d3dx_parameter();
state.parameter.name = string.Empty;
state.parameter.semantic = string.Empty;
state.parameter.class_ = D3DXPARAMETER_CLASS.OBJECT;
state.parameter.type = isVertexShader ? D3DXPARAMETER_TYPE.VERTEXSHADER : D3DXPARAMETER_TYPE.PIXELSHADER;
state.parameter.rows = 0;
state.parameter.columns = 0;
state.parameter.data = dxShader.SharedIndex;
return(state);
}
public scenario_structure_bsp(CacheBase Cache, int Address)
{
cache = Cache;
EndianReader Reader = Cache.Reader;
Reader.SeekTo(Address);
#region sldt/lbsp ID
//lbsp's sections address will be used instead of the one in sbsp
int sectionAddress = 0;
foreach (var item in Cache.IndexItems)
{
if (item.ClassCode == "scnr")
{
Reader.SeekTo(item.Offset + 68);
int cnt = Reader.ReadInt32();
int ptr = Reader.ReadInt32() - Cache.Magic;
int bspIndex = 0;
for (int i = 0; i < cnt; i++)
{
Reader.SeekTo(ptr + 168 * i + 12);
if (Cache.IndexItems.GetItemByID(Reader.ReadInt32()).Offset == Address)
{
bspIndex = i;
break;
}
}
Reader.SeekTo(item.Offset + 1828 + 12);
int sldtID = Reader.ReadInt32();
var sldt = Cache.IndexItems.GetItemByID(sldtID);
int sldtAddress = Cache.IndexItems.GetItemByID(sldtID).Offset;
Reader.SeekTo(sldtAddress + 4);
cnt = Reader.ReadInt32();
ptr = Reader.ReadInt32() - Cache.Magic;
Reader.SeekTo(ptr + 32 * bspIndex + 12);
int lbspID = Reader.ReadInt32();
var lbsp = Cache.IndexItems.GetItemByID(lbspID);
int lbspAddress = Cache.IndexItems.GetItemByID(lbspID).Offset;
Reader.SeekTo(lbspAddress + 116);
sectionAddress = Reader.ReadInt32() - Cache.Magic;
Reader.SeekTo(lbspAddress + 244);
geomRawID = Reader.ReadInt32();
break;
}
}
#endregion
Reader.SeekTo(Address + 236);
XBounds = new Range <float>(Reader.ReadSingle(), Reader.ReadSingle());
YBounds = new Range <float>(Reader.ReadSingle(), Reader.ReadSingle());
ZBounds = new Range <float>(Reader.ReadSingle(), Reader.ReadSingle());
#region Clusters Block
Reader.SeekTo(Address + 308);
int iCount = Reader.ReadInt32();
int iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
Clusters.Add(new Cluster(Cache, iOffset + 288 * i));
}
#endregion
#region Shaders Block
Reader.SeekTo(Address + 320);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
Shaders.Add(new ReachBeta.render_model.Shader(Cache, iOffset + 44 * i));
}
#endregion
#region GeometryInstances Block
Reader.SeekTo(Address + 620);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
GeomInstances.Add(new InstancedGeometry(Cache, iOffset + 168 * i));
}
#endregion
Reader.SeekTo(Address + 796);
RawID1 = Reader.ReadInt32();
Reader.SeekTo(Address + 976);
RawID2 = Reader.ReadInt32();
#region ModelParts Block
Reader.SeekTo(Address + 1112);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
ModelSections.Add(new ReachBeta.render_model.ModelSection(Cache, sectionAddress + 92 * i));
}
#endregion
#region Bounding Boxes Block
Reader.SeekTo(Address + 1124);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
BoundingBoxes.Add(new ReachBeta.render_model.BoundingBox(Cache, iOffset + 52 * i));
}
#endregion
Reader.SeekTo(Address + 1244);
RawID3 = Reader.ReadInt32();
}
private d3dx_state CreateShader(ShaderInfo shaderInfo, string shaderFilename, string shaderXML, bool isVertexShader, ContentProcessorContext context)
{
// Compile the shader.
byte[] bytecode;
if (shaderInfo.Profile == ShaderProfile.DirectX_11 || shaderInfo.Profile == ShaderProfile.OpenGL)
{
throw new NotImplementedException("HLSL not implemented here");
}
else if (shaderInfo.Profile == ShaderProfile.PureGLSL)
{
bytecode = CompileGLSL(shaderInfo, shaderFilename, shaderXML, context);
}
else
{
throw new NotSupportedException("Unknown shader profile!");
}
// First look to see if we already created this same shader.
ShaderData shaderData = null;
foreach (var shader in Shaders)
{
if (bytecode.SequenceEqual(shader.Bytecode))
{
shaderData = shader;
break;
}
}
// Create a new shader.
if (shaderData == null)
{
if (shaderInfo.Profile == ShaderProfile.DirectX_11)
{
throw new NotImplementedException("HLSL not implemented");//shaderData = ShaderData.CreateHLSL(bytecode, isVertexShader, ConstantBuffers, Shaders.Count, shaderInfo.SamplerStates, shaderInfo.Debug);
}
else if (shaderInfo.Profile == ShaderProfile.PureGLSL)
{
shaderData = ShaderData.CreatePureGLSL(bytecode, shaderFilename, isVertexShader, ConstantBuffers, Shaders.Count, shaderInfo.SamplerStates, shaderXML, shaderInfo.Debug);
}
else
{
throw new NotSupportedException("Unknown shader profile!");
}
Shaders.Add(shaderData);
}
var state = new d3dx_state();
state.index = 0;
state.type = STATE_TYPE.CONSTANT;
state.operation = isVertexShader ? (uint)146 : (uint)147;
state.parameter = new d3dx_parameter();
state.parameter.name = string.Empty;
state.parameter.semantic = string.Empty;
state.parameter.class_ = D3DXPARAMETER_CLASS.OBJECT;
state.parameter.type = isVertexShader ? D3DXPARAMETER_TYPE.VERTEXSHADER : D3DXPARAMETER_TYPE.PIXELSHADER;
state.parameter.rows = 0;
state.parameter.columns = 0;
state.parameter.data = shaderData.SharedIndex;
return(state);
}
public virtual void ReadChildData(BinaryReader reader)
{
int x = 0;
for (x = 0; (x < _shaders.Count); x = (x + 1))
{
Shaders.Add(new DecoratorShaderReferenceBlockBlock());
Shaders[x].Read(reader);
}
for (x = 0; (x < _shaders.Count); x = (x + 1))
{
Shaders[x].ReadChildData(reader);
}
for (x = 0; (x < _classes.Count); x = (x + 1))
{
Classes.Add(new DecoratorClassesBlockBlock());
Classes[x].Read(reader);
}
for (x = 0; (x < _classes.Count); x = (x + 1))
{
Classes[x].ReadChildData(reader);
}
for (x = 0; (x < _models.Count); x = (x + 1))
{
Models.Add(new DecoratorModelsBlockBlock());
Models[x].Read(reader);
}
for (x = 0; (x < _models.Count); x = (x + 1))
{
Models[x].ReadChildData(reader);
}
for (x = 0; (x < _rawVertices.Count); x = (x + 1))
{
RawVertices.Add(new DecoratorModelVerticesBlockBlock());
RawVertices[x].Read(reader);
}
for (x = 0; (x < _rawVertices.Count); x = (x + 1))
{
RawVertices[x].ReadChildData(reader);
}
for (x = 0; (x < _indices.Count); x = (x + 1))
{
Indices.Add(new DecoratorModelIndicesBlockBlock());
Indices[x].Read(reader);
}
for (x = 0; (x < _indices.Count); x = (x + 1))
{
Indices[x].ReadChildData(reader);
}
for (x = 0; (x < _cachedData.Count); x = (x + 1))
{
CachedData.Add(new CachedDataBlockBlock());
CachedData[x].Read(reader);
}
for (x = 0; (x < _cachedData.Count); x = (x + 1))
{
CachedData[x].ReadChildData(reader);
}
_resourceData.ReadBinary(reader);
for (x = 0; (x < _resources.Count); x = (x + 1))
{
Resources.Add(new GlobalGeometryBlockResourceBlockBlock());
Resources[x].Read(reader);
}
for (x = 0; (x < _resources.Count); x = (x + 1))
{
Resources[x].ReadChildData(reader);
}
}
public void AddShader(Shader shader)
{
Shaders.Add(shader);
shader.Group = this;
}
public render_model(CacheBase Cache, int Address)
{
cache = Cache;
EndianReader Reader = Cache.Reader;
Reader.SeekTo(Address);
Name = Cache.Strings.GetItemByID(Reader.ReadInt16());
//Flags = new Bitmask(Reader.ReadInt32());
#region BoundingBox Block
Reader.SeekTo(Address + 20);
int iCount = Reader.ReadInt32();
int iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
BoundingBoxes.Add(new BoundingBox(Cache, iOffset + 56 * i));
}
#endregion
#region Regions Block
Reader.SeekTo(Address + 28);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
Regions.Add(new Region(Cache, iOffset + 16 * i));
}
#endregion
#region ModelParts Block
Reader.SeekTo(Address + 36);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
ModelSections.Add(new ModelSection(Cache, iOffset + 92 * i)
{
FacesIndex = i, VertsIndex = i, NodeIndex = 255
});
}
Reader.SeekTo(Address + 72);
#endregion
#region Nodes Block
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
Nodes.Add(new Node(Cache, iOffset + 96 * i));
}
#endregion
#region MarkerGroups Block
Reader.SeekTo(Address + 88);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
MarkerGroups.Add(new MarkerGroup(Cache, iOffset + 12 * i));
}
#endregion
#region Shaders Block
Reader.SeekTo(Address + 96);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
Shaders.Add(new Shader(Cache, iOffset + 32 * i));
}
#endregion
}
private d3dx_state CreateShader(ShaderInfo shaderInfo, string shaderFunction, string shaderProfile, bool isVertexShader)
{
// Compile the shader.
byte[] bytecode;
if (shaderInfo.Profile == ShaderProfile.DirectX_11 || shaderInfo.Profile == ShaderProfile.OpenGL)
{
// For now GLSL is only supported via translation
// using MojoShader which works from HLSL bytecode.
bytecode = CompileHLSL(shaderInfo, shaderFunction, shaderProfile);
}
else if (shaderInfo.Profile == ShaderProfile.PlayStation4)
{
bytecode = CompilePSSL(shaderInfo, shaderFunction, shaderProfile);
}
else
{
throw new NotSupportedException("Unknown shader profile!");
}
// First look to see if we already created this same shader.
ShaderData shaderData = null;
foreach (var shader in Shaders)
{
if (bytecode.SequenceEqual(shader.Bytecode))
{
shaderData = shader;
break;
}
}
// Create a new shader.
if (shaderData == null)
{
if (shaderInfo.Profile == ShaderProfile.DirectX_11)
{
shaderData = ShaderData.CreateHLSL(bytecode, isVertexShader, ConstantBuffers, Shaders.Count, shaderInfo.SamplerStates, shaderInfo.Debug);
}
else if (shaderInfo.Profile == ShaderProfile.OpenGL)
{
shaderData = ShaderData.CreateGLSL(bytecode, isVertexShader, ConstantBuffers, Shaders.Count, shaderInfo.SamplerStates, shaderInfo.Debug);
}
else if (shaderInfo.Profile == ShaderProfile.PlayStation4)
{
shaderData = ShaderData.CreatePSSL(bytecode, isVertexShader, ConstantBuffers, Shaders.Count, shaderInfo.SamplerStates, shaderInfo.Debug);
}
else
{
throw new NotSupportedException("Unknown shader profile!");
}
Shaders.Add(shaderData);
}
var state = new d3dx_state();
state.index = 0;
state.type = STATE_TYPE.CONSTANT;
state.operation = isVertexShader ? (uint)146 : (uint)147;
state.parameter = new d3dx_parameter();
state.parameter.name = string.Empty;
state.parameter.semantic = string.Empty;
state.parameter.class_ = D3DXPARAMETER_CLASS.OBJECT;
state.parameter.type = isVertexShader ? D3DXPARAMETER_TYPE.VERTEXSHADER : D3DXPARAMETER_TYPE.PIXELSHADER;
state.parameter.rows = 0;
state.parameter.columns = 0;
state.parameter.data = shaderData.SharedIndex;
return(state);
}
public scenario_structure_bsp(CacheBase Cache, int Address)
{
cache = Cache;
EndianReader Reader = Cache.Reader;
Reader.SeekTo(Address);
#region sldt/lbsp ID
//lbsp's sections address will be used instead of the one in sbsp
int sectCount = 0, sectionAddress = 0, bbCount = 0, bbAddr = 0;
foreach (var item in Cache.IndexItems)
{
if (item.ClassCode == "scnr")
{
Reader.SeekTo(item.Offset + 160);
int cnt = Reader.ReadInt32();
int ptr = Reader.ReadInt32() - Cache.Magic;
int bspIndex = 0;
for (int i = 0; i < cnt; i++)
{
Reader.SeekTo(ptr + 336 * i + 12);
if (Cache.IndexItems.GetItemByID(Reader.ReadInt32()).Offset == Address)
{
bspIndex = i;
break;
}
}
Reader.SeekTo(item.Offset + 1896 + 12);
int sldtID = Reader.ReadInt32();
int sldtAddress = Cache.IndexItems.GetItemByID(sldtID).Offset;
Reader.SeekTo(sldtAddress + 4);
cnt = Reader.ReadInt32();
ptr = Reader.ReadInt32() - Cache.Magic;
Reader.SeekTo(ptr + 32 * bspIndex + 12);
int lbspID = Reader.ReadInt32();
int lbspAddress = Cache.IndexItems.GetItemByID(lbspID).Offset;
Reader.SeekTo(lbspAddress + 320); //320, 512, 692
sectCount = Reader.ReadInt32();
sectionAddress = Reader.ReadInt32() - Cache.Magic;
Reader.SeekTo(lbspAddress + 344); //344, 536, 716
bbCount = Reader.ReadInt32();
bbAddr = Reader.ReadInt32() - Cache.Magic;
Reader.SeekTo(lbspAddress + 464); //464, 656, 836
geomRawID = Reader.ReadInt32();
break;
}
}
#endregion
Reader.SeekTo(Address + 268);
XBounds = new Range <float>(Reader.ReadSingle(), Reader.ReadSingle());
YBounds = new Range <float>(Reader.ReadSingle(), Reader.ReadSingle());
ZBounds = new Range <float>(Reader.ReadSingle(), Reader.ReadSingle());
#region Clusters Block
Reader.SeekTo(Address + 340);
int iCount = Reader.ReadInt32();
int iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < 1; i++)
{
Clusters.Add(new Cluster(Cache, iOffset + 140 * i));
}
#endregion
#region Shaders Block
Reader.SeekTo(Address + 352);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
Shaders.Add(new Halo4Retail.render_model.Shader(Cache, iOffset + 44 * i));
}
#endregion
#region GeometryInstances Block
Reader.SeekTo(Address + 640);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
GeomInstances.Add(new InstancedGeometry(Cache, iOffset + 4 * i));
}
#region Load Fixup Data
Reader.SeekTo(Address + 1364);
int id = Reader.ReadInt32();
var entry = Cache.zone.RawEntries[id & 0xFFFF];
var er = new EndianReader(new MemoryStream(Cache.GetRawFromID(id)), EndianFormat.Big);
int addr = entry.Fixups[entry.Fixups.Count - 10].Offset;
for (int i = 0; i < GeomInstances.Count; i++)
{
er.SeekTo(addr + 148 * i);
var geom = GeomInstances[i];
geom.TransformScale = er.ReadSingle();
geom.TransformMatrix = Matrix4x3.Read(er);
er.ReadUInt16();
er.ReadUInt16();
er.ReadInt32();
er.ReadUInt16();
geom.SectionIndex = er.ReadUInt16();
}
er.Close();
er.Dispose();
#endregion
#endregion
Reader.SeekTo(Address + 844);
RawID1 = Reader.ReadInt32();
Reader.SeekTo(Address + 1048);
RawID2 = Reader.ReadInt32();
#region ModelSections Block
Reader.SeekTo(Address + 1144);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
if (sectionAddress == -Cache.Magic)
{
sectionAddress = iOffset; //null address in lbsp
}
for (int i = 0; i < sectCount; i++)
{
ModelSections.Add(new Halo4Retail.render_model.ModelSection(Cache, sectionAddress + 112 * i));
}
#endregion
#region Bounding Boxes Block
Reader.SeekTo(Address + 1168);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < bbCount; i++)
{
BoundingBoxes.Add(new Halo4Retail.render_model.BoundingBox(Cache, bbAddr + 52 * i));
}
#endregion
Reader.SeekTo(Address + 1288);
RawID3 = Reader.ReadInt32();
}
internal override bool ParseNodeBodyElement(string id, VRMLParser parser)
{
int line = parser.Line;
if (id == "fillProperties")
{
X3DNode node = parser.ParseSFNodeValue();
if (node != null)
{
FillProperties = node as IX3DFillPropertiesNode;
if (FillProperties == null)
{
parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
}
}
}
else if (id == "lineProperties")
{
X3DNode node = parser.ParseSFNodeValue();
if (node != null)
{
LineProperties = node as IX3DLinePropertiesNode;
if (LineProperties == null)
{
parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
}
}
}
else if (id == "material")
{
X3DNode node = parser.ParseSFNodeValue();
if (node != null)
{
Material = node as X3DMaterialNode;
if (Material == null)
{
parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
}
}
}
else if (id == "shaders")
{
List <X3DNode> nodes = parser.ParseSFNodeOrMFNodeValue();
foreach (X3DNode node in nodes)
{
X3DShaderNode sn = node as X3DShaderNode;
if (sn == null)
{
parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
}
else
{
Shaders.Add(sn);
}
}
}
else if (id == "texture")
{
X3DNode node = parser.ParseSFNodeValue();
if (node != null)
{
Texture = node as X3DTextureNode;
if (Texture == null)
{
parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
}
}
}
else if (id == "textureTransform")
{
X3DNode node = parser.ParseSFNodeValue();
if (node != null)
{
TextureTransform = node as X3DTextureTransformNode;
if (TextureTransform == null)
{
parser.ErrorParsingNode(VRMLReaderError.UnexpectedNodeType, this, id, node, line);
}
}
}
else
{
return(false);
}
return(true);
}
/// <summary />
public ShaderLibrary(RenderHost renderHost)
{
Shaders.Add(ShaderPosition = new Position.Shader(renderHost));
Shaders.Add(ShaderPositionColor = new PositionColor.Shader(renderHost));
}
public scenario_structure_bsp(CacheBase Cache, int Address)
{
cache = Cache;
EndianReader Reader = Cache.Reader;
Reader.SeekTo(Address);
#region sldt ID
//sldt's sections address will be used instead of the one in sbsp
int sectionAddress = 0;
foreach (var item in Cache.IndexItems)
{
if (item.ClassCode == "scnr")
{
Reader.SeekTo(item.Offset + 20);
int cnt = Reader.ReadInt32();
int ptr = Reader.ReadInt32() - Cache.Magic;
int bspIndex = 0;
for (int i = 0; i < cnt; i++)
{
Reader.SeekTo(ptr + 108 * i + 12);
if (Cache.IndexItems.GetItemByID(Reader.ReadInt32()).Offset == Address)
{
bspIndex = i;
break;
}
}
Reader.SeekTo(item.Offset + 1776 + 12);
int sldtID = Reader.ReadInt32();
int sldtAddress = Cache.IndexItems.GetItemByID(sldtID).Offset;
Reader.SeekTo(sldtAddress + 4);
cnt = Reader.ReadInt32();
ptr = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < cnt; i++)
{
Reader.SeekTo(ptr + 436 * i + 2);
if (Reader.ReadInt16() != bspIndex)
{
continue;
}
Reader.SeekTo(ptr + 436 * i + 312);
sectionAddress = Reader.ReadInt32() - Cache.Magic;
Reader.SeekTo(ptr + 436 * i + 428);
geomRawID = Reader.ReadInt32();
}
break;
}
}
#endregion
Reader.SeekTo(Address + 60);
XBounds = new RealBounds(Reader.ReadSingle(), Reader.ReadSingle());
YBounds = new RealBounds(Reader.ReadSingle(), Reader.ReadSingle());
ZBounds = new RealBounds(Reader.ReadSingle(), Reader.ReadSingle());
#region Clusters Block
Reader.SeekTo(Address + 180);
int iCount = Reader.ReadInt32();
int iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
Clusters.Add(new Cluster(Cache, iOffset + 220 * i));
}
#endregion
#region Shaders Block
Reader.SeekTo(Address + 192);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
Shaders.Add(new Halo3Beta.render_model.Shader(Cache, iOffset + 36 * i));
}
#endregion
#region GeometryInstances Block
Reader.SeekTo(Address + 432);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
GeomInstances.Add(new InstancedGeometry(Cache, iOffset + 120 * i));
}
#endregion
Reader.SeekTo(Address + 580);
RawID1 = Reader.ReadInt32();
#region ModelSections Block
Reader.SeekTo(Address + 740);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
ModelSections.Add(new Halo3Beta.render_model.ModelSection(Cache, sectionAddress + 76 * i));
}
#endregion
#region Bounding Boxes Block
Reader.SeekTo(Address + 752);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
BoundingBoxes.Add(new Halo3Beta.render_model.BoundingBox(Cache, iOffset + 44 * i));
}
#endregion
Reader.SeekTo(Address + 860);
RawID2 = Reader.ReadInt32();
Reader.SeekTo(Address + 892);
RawID3 = Reader.ReadInt32();
}
public scenario_structure_bsp(CacheBase Cache, int Address)
{
cache = Cache;
EndianReader Reader = Cache.Reader;
Reader.SeekTo(Address);
#region sldt/lbsp ID
//lbsp's sections address will be used instead of the one in sbsp
int sectionAddress = 0;
int sectionCount = 0;
foreach (var item in Cache.IndexItems)
{
if (item.ClassCode == "scnr")
{
Reader.SeekTo(item.Offset + 76);
int cnt = Reader.ReadInt32();
int ptr = Reader.ReadInt32() - Cache.Magic;
int bspIndex = 0;
for (int i = 0; i < cnt; i++)
{
Reader.SeekTo(ptr + 172 * i + 12);
if (Cache.IndexItems.GetItemByID(Reader.ReadInt32()).Offset == Address)
{
bspIndex = i;
break;
}
}
Reader.SeekTo(item.Offset + 1844 + 12);
int sldtID = Reader.ReadInt32();
int sldtAddress = Cache.IndexItems.GetItemByID(sldtID).Offset;
Reader.SeekTo(sldtAddress + 4);
cnt = Reader.ReadInt32();
ptr = Reader.ReadInt32() - Cache.Magic;
Reader.SeekTo(ptr + 32 * bspIndex + 12);
int lbspID = Reader.ReadInt32();
int lbspAddress = Cache.IndexItems.GetItemByID(lbspID).Offset;
Reader.SeekTo(lbspAddress + 124);
sectionCount = Reader.ReadInt32();
sectionAddress = Reader.ReadInt32() - Cache.Magic;
Reader.SeekTo(lbspAddress + 268);
geomRawID = Reader.ReadInt32();
break;
}
}
#endregion
Reader.SeekTo(Address + 236);
XBounds = new RealBounds(Reader.ReadSingle(), Reader.ReadSingle());
YBounds = new RealBounds(Reader.ReadSingle(), Reader.ReadSingle());
ZBounds = new RealBounds(Reader.ReadSingle(), Reader.ReadSingle());
#region Clusters Block
Reader.SeekTo(Address + 308);
int iCount = Reader.ReadInt32();
int iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
Clusters.Add(new Cluster(Cache, iOffset + 140 * i));
}
#endregion
#region Shaders Block
Reader.SeekTo(Address + 320);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
Shaders.Add(new ReachRetail.render_model.Shader(Cache, iOffset + 44 * i));
}
#endregion
#region GeometryInstances Block
Reader.SeekTo(Address + 608);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
GeomInstances.Add(new InstancedGeometry(Cache, iOffset + 4 * i));
}
#region Load Fixup Data
Reader.SeekTo(Address + 1298);
int id = Reader.ReadUInt16();
var entry = Cache.zone.RawEntries[id];
var er = new EndianReader(new MemoryStream(Cache.zone.FixupData), EndianFormat.BigEndian);
int addr = entry.Fixups[entry.Fixups.Count - 10].Offset;
for (int i = 0; i < GeomInstances.Count; i++)
{
er.SeekTo(entry.FixupOffset + addr + 156 * i);
var geom = GeomInstances[i];
geom.TransformScale = er.ReadSingle();
geom.TransformMatrix.m11 = er.ReadSingle();
geom.TransformMatrix.m12 = er.ReadSingle();
geom.TransformMatrix.m13 = er.ReadSingle();
geom.TransformMatrix.m21 = er.ReadSingle();
geom.TransformMatrix.m22 = er.ReadSingle();
geom.TransformMatrix.m23 = er.ReadSingle();
geom.TransformMatrix.m31 = er.ReadSingle();
geom.TransformMatrix.m32 = er.ReadSingle();
geom.TransformMatrix.m33 = er.ReadSingle();
geom.TransformMatrix.m41 = er.ReadSingle();
geom.TransformMatrix.m42 = er.ReadSingle();
geom.TransformMatrix.m43 = er.ReadSingle();
er.ReadUInt16();
er.ReadUInt16();
er.ReadUInt16();
geom.SectionIndex = er.ReadUInt16();
}
er.Close();
er.Dispose();
#endregion
#endregion
Reader.SeekTo(Address + 796);
RawID1 = Reader.ReadInt32();
Reader.SeekTo(Address + 976);
RawID2 = Reader.ReadInt32();
#region ModelParts Block
Reader.SeekTo(Address + 1100);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
if (sectionAddress == -Cache.Magic)
{
sectionAddress = iOffset; //null address in lbsp
}
for (int i = 0; i < iCount; i++)
{
ModelSections.Add(new ReachRetail.render_model.ModelSection(Cache, sectionAddress + 92 * i));
}
#endregion
#region Bounding Boxes Block
Reader.SeekTo(Address + 1112);
iCount = Reader.ReadInt32();
iOffset = Reader.ReadInt32() - Cache.Magic;
for (int i = 0; i < iCount; i++)
{
BoundingBoxes.Add(new ReachRetail.render_model.BoundingBox(Cache, iOffset + 52 * i));
}
#endregion
Reader.SeekTo(Address + 1244);
RawID3 = Reader.ReadInt32();
}
