protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(GetSerializedVersion(container.ExportVersion));
node.Add(SceneName, Scene.ExportYAML(container));
node.Add(LightmapsName, Lightmaps.ExportYAML(container));
if (IsReadAOTextures(container.ExportVersion))
{
node.Add(AOTexturesName, GetAOTextures(container.Version).ExportYAML(container));
}
if (IsReadLightmapsCacheFiles(container.Version))
{
node.Add(LightmapsCacheFilesName, GetLightmapsCacheFiles(container.Version).ExportYAML());
}
node.Add(LightProbesName, LightProbes.ExportYAML(container));
node.Add(LightmapsModeName, LightmapsMode);
node.Add(BakedAmbientProbeInLinearName, BakedAmbientProbeInLinear.ExportYAML(container));
node.Add(LightmappedRendererDataName, LightmappedRendererData.ExportYAML(container));
node.Add(LightmappedRendererDataIDsName, LightmappedRendererDataIDs.ExportYAML(container));
node.Add(EnlightenSceneMappingName, EnlightenSceneMapping.ExportYAML(container));
node.Add(EnlightenSceneMappingRendererIDsName, EnlightenSceneMappingRendererIDs.ExportYAML(container));
node.Add(LightsName, Lights.ExportYAML(container));
node.Add(LightBakingOutputsName, LightBakingOutputs.ExportYAML(container));
if (IsReadBakedReflectionProbeCubemapCacheFiles(container.ExportVersion))
{
node.Add(BakedReflectionProbeCubemapCacheFilesName, GetBakedReflectionProbeCubemapCacheFiles(container.Version).ExportYAML());
}
node.Add(BakedReflectionProbeCubemapsName, BakedReflectionProbeCubemaps.ExportYAML(container));
node.Add(BakedReflectionProbesName, BakedReflectionProbes.ExportYAML(container));
node.Add(EnlightenDataName, EnlightenData.ExportYAML());
node.Add(EnlightenDataVersionName, EnlightenDataVersion);
return(node);
}
public IEnumerable <IBitmap> GetAllBitmaps()
{
var complete = new List <int>();
using (var reader = cache.CreateReader(cache.DefaultAddressTranslator))
{
foreach (var mat in Lightmaps.SelectMany(lm => lm.Materials))
{
var bitmTag = Halo1Common.GetShaderDiffuse(mat.ShaderReference, reader);
if (bitmTag == null || complete.Contains(bitmTag.Id))
{
continue;
}
complete.Add(bitmTag.Id);
yield return(bitmTag.ReadMetadata <bitmap>());
}
}
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.Add("m_Scene", Scene.ExportYAML(container));
node.Add("m_Lightmaps", Lightmaps.ExportYAML(container));
node.Add("m_LightProbes", LightProbes.ExportYAML(container));
node.Add("m_LightmapsMode", LightmapsMode);
node.Add("m_BakedAmbientProbeInLinear", BakedAmbientProbeInLinear.ExportYAML(container));
node.Add("m_LightmappedRendererData", LightmappedRendererData.ExportYAML(container));
node.Add("m_LightmappedRendererDataIDs", LightmappedRendererDataIDs.ExportYAML(container));
node.Add("m_EnlightenSceneMapping", EnlightenSceneMapping.ExportYAML(container));
node.Add("m_EnlightenSceneMappingRendererIDs", EnlightenSceneMappingRendererIDs.ExportYAML(container));
node.Add("m_Lights", Lights.ExportYAML(container));
node.Add("m_LightBakingOutputs", LightBakingOutputs.ExportYAML(container));
node.Add("m_BakedReflectionProbeCubemaps", BakedReflectionProbeCubemaps.ExportYAML(container));
node.Add("m_BakedReflectionProbes", BakedReflectionProbes.ExportYAML(container));
node.Add("m_EnlightenData", EnlightenData.ExportYAML());
node.Add("m_EnlightenDataVersion", EnlightenDataVersion);
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion));
if (HasLightProbesLegacy(container.ExportVersion))
{
node.Add(LightProbesLegacyName, LightProbesLegacy.ExportYAML(container));
}
if (HasGIWorkflowMode(container.ExportVersion, container.ExportFlags))
{
node.Add(GIWorkflowModeName, (int)GetExportGIWorkflowMode(container.Version, container.Flags));
}
if (HasLightProbes(container.ExportVersion, container.ExportFlags))
{
node.Add(LightProbesName, LightProbes.ExportYAML(container));
}
if (HasLightmaps(container.ExportVersion, container.ExportFlags))
{
node.Add(LightmapsName, Lightmaps.ExportYAML(container));
}
if (HasLightmapsModeLegacy(container.ExportVersion))
{
node.Add(LightmapsModeLegacyName, (int)LightmapsModeLegacy);
}
if (HasLightmapsMode(container.ExportVersion, container.ExportFlags))
{
node.Add(LightmapsModeName, (int)LightmapsMode);
}
if (HasBakedColorSpace(container.ExportVersion))
{
node.Add(BakedColorSpaceName, (int)BakedColorSpace);
}
if (HasUseDualLightmapsInForward(container.ExportVersion))
{
node.Add(UseDualLightmapsInForwardName, UseDualLightmapsInForward);
}
if (HasGISettings(container.ExportVersion))
{
node.Add(GISettingsName, GetExportGISettings(container.Version).ExportYAML(container));
}
#if UNIVERSAL
if (HasLightmapEditorSettings(container.ExportVersion, container.ExportFlags))
{
node.Add(LightmapEditorSettingsName, GetExportLightmapEditorSettings(container).ExportYAML(container));
}
if (HasLightingDataAsset(container.ExportVersion, container.ExportFlags))
{
node.Add(LightingDataAssetName, GetLightingDataAsset(container.Version, container.Flags).ExportYAML(container));
}
#endif
if (HasRuntimeCPUUsage(container.ExportVersion))
{
node.Add(RuntimeCPUUsageName, RuntimeCPUUsage);
}
if (HasUseShadowmask(container.ExportVersion))
{
if (IsBoolShadowmask(container.ExportVersion))
{
node.Add(UseShadowmaskName, GetExportUseShadowmask(container.Version));
}
else
{
node.Add(ShadowMaskModeName, ShadowMaskMode);
}
}
return(node);
}
public override void Write(AssetWriter writer)
{
base.Write(writer);
if (HasLightProbesLegacy(writer.Version))
{
LightProbesLegacy.Write(writer);
}
if (HasEnlightenSceneMapping(writer.Version, writer.Flags))
{
EnlightenSceneMapping.Write(writer);
}
if (HasGIWorkflowMode(writer.Version, writer.Flags))
{
writer.Write((int)GIWorkflowMode);
}
if (HasLightProbes(writer.Version, writer.Flags))
{
LightProbes.Write(writer);
}
if (HasLightmaps(writer.Version, writer.Flags))
{
Lightmaps.Write(writer);
}
if (IsAlign1(writer.Version, writer.Flags))
{
writer.AlignStream();
}
if (HasLightmapsModeLegacy(writer.Version))
{
writer.Write((int)LightmapsModeLegacy);
}
if (HasLightmapsMode(writer.Version, writer.Flags))
{
writer.Write((int)LightmapsMode);
}
if (HasBakedColorSpace(writer.Version))
{
writer.Write((int)BakedColorSpace);
}
if (HasUseDualLightmapsInForward(writer.Version))
{
writer.Write(UseDualLightmapsInForward);
}
if (IsAlign2(writer.Version))
{
writer.AlignStream();
}
if (HasGISettings(writer.Version))
{
GISettings.Write(writer);
}
#if UNIVERSAL
if (HasLightmapEditorSettings(writer.Version, writer.Flags))
{
LightmapEditorSettings.Write(writer);
}
if (HasLightingDataAsset(writer.Version, writer.Flags))
{
LightingDataAsset.Write(writer);
}
#endif
if (HasRuntimeCPUUsage(writer.Version))
{
writer.Write(RuntimeCPUUsage);
}
if (HasUseShadowmask(writer.Version))
{
if (IsBoolShadowmask(writer.Version))
{
writer.Write(UseShadowmask);
}
else
{
writer.Write(ShadowMaskMode);
}
}
}
public IGeometryModel ReadGeometry(int lod)
{
if (lod < 0 || lod >= ((IRenderGeometry)this).LodCount)
{
throw new ArgumentOutOfRangeException(nameof(lod));
}
using (var reader = cache.CreateReader(cache.DefaultAddressTranslator))
{
var model = new GeometryModel(item.FileName())
{
CoordinateSystem = CoordinateSystem.Default
};
var shaderRefs = Lightmaps.SelectMany(m => m.Materials)
.Where(m => m.ShaderReference.TagId >= 0)
.GroupBy(m => m.ShaderReference.TagId)
.Select(g => g.First().ShaderReference)
.ToList();
var shaderIds = shaderRefs.Select(r => r.TagId).ToList();
model.Materials.AddRange(Halo1Common.GetMaterials(shaderRefs, reader));
reader.Seek(SurfacePointer.Address, SeekOrigin.Begin);
var indices = reader.ReadEnumerable <ushort>(SurfaceCount * 3).ToArray();
var gRegion = new GeometryRegion {
Name = "Clusters"
};
int sectionIndex = 0;
foreach (var section in Lightmaps)
{
if (section.Materials.Count == 0)
{
continue;
}
var localIndices = new List <int>();
var vertices = new List <WorldVertex>();
var submeshes = new List <IGeometrySubmesh>();
var gPermutation = new GeometryPermutation
{
SourceIndex = Lightmaps.IndexOf(section),
Name = sectionIndex.ToString("D3", CultureInfo.CurrentCulture),
MeshIndex = sectionIndex,
MeshCount = 1
};
foreach (var submesh in section.Materials)
{
reader.Seek(submesh.VertexPointer.Address, SeekOrigin.Begin);
submeshes.Add(new GeometrySubmesh
{
MaterialIndex = (short)shaderIds.IndexOf(submesh.ShaderReference.TagId),
IndexStart = localIndices.Count,
IndexLength = submesh.SurfaceCount * 3
});
localIndices.AddRange(
indices.Skip(submesh.SurfaceIndex * 3)
.Take(submesh.SurfaceCount * 3)
.Select(i => i + vertices.Count)
);
var vertsTemp = reader.ReadEnumerable <WorldVertex>(submesh.VertexCount).ToList();
vertices.AddRange(vertsTemp);
}
gRegion.Permutations.Add(gPermutation);
model.Meshes.Add(new GeometryMesh
{
IndexFormat = IndexFormat.TriangleList,
VertexWeights = VertexWeights.None,
Indicies = localIndices.ToArray(),
Vertices = vertices.ToArray(),
Submeshes = submeshes
});
sectionIndex++;
}
model.Regions.Add(gRegion);
return(model);
}
}
