private void ConvertShaderCortana(ShaderCortana shaderCortana, Stream cacheStream, Dictionary <ResourceLocation, Stream> resourceStreams)
{
var render_method_option_indices = shaderCortana.RenderMethodDefinitionOptionIndices.Select(c => (int)c.OptionIndex).ToList();
//CachedTagInstance newCortanaShaderInstance = CacheContext.TagCache.AllocateTag(TagGroup.Instances[groupTag]);
//var ho_cortana_shader = (ShaderCortana)Activator.CreateInstance(typeof(ShaderCortana));
var rmdf_instance = shaderCortana.BaseRenderMethod;
var rmdf = CacheContext.Deserialize <RenderMethodDefinition>(new TagSerializationContext(cacheStream, CacheContext, rmdf_instance));
//var shader_instance = CacheContext.GetTag<Shader>(@"shaders\invalid");
//var shader = CacheContext.Deserialize<Shader>(new TagSerializationContext(cacheStream, CacheContext, shader_instance));
//ho_cortana_shader.ImportData = shader.ImportData;
//ho_cortana_shader.ShaderProperties = shader.ShaderProperties;
var shader_properties = shaderCortana.ShaderProperties[0];
shader_properties.ShaderMaps = new List <RenderMethod.ShaderProperty.ShaderMap>();
shader_properties.Arguments = new List <RenderMethod.ShaderProperty.Argument>();
shader_properties.Unknown = new List <RenderMethod.ShaderProperty.UnknownBlock1>();
shader_properties.DrawModes = new List <RenderMethodTemplate.DrawMode>();
shader_properties.Unknown3 = new List <RenderMethod.ShaderProperty.UnknownBlock3>();
shader_properties.ArgumentMappings = new List <RenderMethod.ShaderProperty.ArgumentMapping>();
shader_properties.AnimationProperties = new List <RenderMethod.AnimationPropertiesBlock>();
List <RenderMethodOption.OptionBlock> templateOptions = new List <RenderMethodOption.OptionBlock>();
for (int i = 0; i < rmdf.Methods.Count; i++)
{
var method = rmdf.Methods[i];
int selected_option_index = render_method_option_indices.Count > i ? render_method_option_indices[i] : 0;
var selected_option = method.ShaderOptions[selected_option_index];
var rmop_instance = selected_option.Option;
if (rmop_instance != null)
{
var rmop = CacheContext.Deserialize <RenderMethodOption>(new TagSerializationContext(cacheStream, CacheContext, rmop_instance));
templateOptions.AddRange(rmop.Options);
}
}
RenderMethodTemplate rmt2 = null;
if (shader_properties.Template == null)
{
GenerateCortanaRMT2Tag(
render_method_option_indices,
cacheStream,
resourceStreams,
out CachedTagInstance rmt2Instance,
out RenderMethodTemplate newRMT2);
shader_properties.Template = rmt2Instance;
rmt2 = newRMT2;
}
else
{
rmt2 = CacheContext.Deserialize <RenderMethodTemplate>(new TagSerializationContext(cacheStream, CacheContext, shader_properties.Template));
}
//shader_properties.DrawModes = rmt2.DrawModes;
var shaderFunctions = new List <RenderMethod.AnimationPropertiesBlock>();
var shaderVectorArguments = new RenderMethod.ShaderProperty.Argument[rmt2.VectorArguments.Count];
var shaderSamplerArguments = new RenderMethod.ShaderProperty.ShaderMap[rmt2.SamplerArguments.Count];
for (int rmt2SamplerIndex = 0; rmt2SamplerIndex < rmt2.SamplerArguments.Count; rmt2SamplerIndex++)
{
var rmt2SamplerArgument = rmt2.SamplerArguments[rmt2SamplerIndex];
var name = rmt2SamplerArgument.Name;
var name_str = CacheContext.GetString(name);
var shaderSamplerArgument = new RenderMethod.ShaderProperty.ShaderMap();
{
foreach (var importData in shaderCortana.ImportData)
{
if (importData.Type != RenderMethodOption.OptionBlock.OptionDataType.Sampler)
{
continue;
}
if (importData.Name.Index != name.Index)
{
continue;
}
if (importData.Bitmap != null)
{
shaderSamplerArgument.Bitmap = importData.Bitmap;
goto datafound;
}
}
foreach (var deafult_option in templateOptions)
{
if (deafult_option.Type != RenderMethodOption.OptionBlock.OptionDataType.Sampler)
{
continue;
}
if (deafult_option.Name.Index != name.Index)
{
continue;
}
shaderSamplerArgument.Bitmap = deafult_option.Bitmap;
goto datafound;
}
shaderSamplerArguments[rmt2SamplerIndex] = shaderSamplerArgument;
datafound:
if (shaderSamplerArgument.Bitmap == null)
{
Console.WriteLine($"WARNING: RMCT Conversion couldn't find a shader map for {name_str}");
shaderSamplerArgument.Bitmap = CacheContext.GetTag <Bitmap>(@"shaders\default_bitmaps\bitmaps\gray_50_percent");
}
shaderSamplerArguments[rmt2SamplerIndex] = shaderSamplerArgument;
}
{
int xform_index = GetExistingXFormArgumentIndex(name, rmt2.VectorArguments);
if (xform_index == -1)
{
Console.WriteLine($"WARNING: RMCT Conversion couldn't find a shader xform argument for {name_str}. Defaulting to 0");
xform_index = 0;
}
else
{
var shaderVectorArgument = ProcessArgument(rmt2SamplerArgument, shaderFunctions, templateOptions, shaderCortana);
shaderVectorArguments[xform_index] = shaderVectorArgument;
}
shaderSamplerArgument.XFormArgumentIndex = (sbyte)xform_index;
}
}
shader_properties.ShaderMaps = shaderSamplerArguments.ToList();
for (int rmt2ArgumentIndex = 0; rmt2ArgumentIndex < rmt2.VectorArguments.Count; rmt2ArgumentIndex++)
{
if (shaderVectorArguments[rmt2ArgumentIndex] != null)
{
continue;
}
var vectorArgument = rmt2.VectorArguments[rmt2ArgumentIndex];
var shaderArgument = ProcessArgument(vectorArgument, shaderFunctions, templateOptions, shaderCortana);
shaderVectorArguments[rmt2ArgumentIndex] = shaderArgument;
}
shader_properties.Arguments = shaderVectorArguments.ToList();
shader_properties.AnimationProperties = shaderFunctions;
if (shaderCortana.Material.Index == 0)
{
if (CacheContext.StringIdCache.Contains("default_material"))
{
shaderCortana.Material = CacheContext.StringIdCache.GetStringId("default_material");
}
}
//shader_cortana.Material = shader.Material;
//ho_cortana_shader.BaseRenderMethod = shader.BaseRenderMethod;
//newCortanaShaderInstance.Name = blamTag.Name;
//CacheContext.Serialize(new TagSerializationContext(cacheStream, CacheContext, newCortanaShaderInstance), ho_cortana_shader);
//CacheContext.SaveTagNames();
}