public static Task <byte[]> GenerateAsync(
ShaderStage stage,
Albedo albedo,
Bump_Mapping bump_mapping,
Alpha_Test alpha_test,
Specular_Mask specular_mask,
Material_Model material_model,
Environment_Mapping environment_mapping,
Self_Illumination self_illumination,
Blend_Mode blend_mode,
Parallax parallax,
Misc misc,
Distortion distortion,
Soft_fade soft_fade
)
{
return(Task.Run(() => GenerateShader(
stage,
albedo,
bump_mapping,
alpha_test,
specular_mask,
material_model,
environment_mapping,
self_illumination,
blend_mode,
parallax,
misc,
distortion,
soft_fade
)));
}
public DecalGenerator(byte[] options, bool applyFixes = false)
{
this.albedo = (Albedo)options[0];
this.blend_mode = (Blend_Mode)options[1];
this.render_pass = (Render_Pass)options[2];
this.specular = (Specular)options[3];
this.bump_mapping = (Bump_Mapping)options[4];
this.tinting = (Tinting)options[5];
ApplyFixes = applyFixes;
DecalIsSimple = this.render_pass == Render_Pass.Pre_Lighting && this.bump_mapping == Bump_Mapping.Leave;
TemplateGenerationValid = true;
}
/// <summary>
/// Generator instantiation for method specific shaders.
/// </summary>
public DecalGenerator(Albedo albedo, Blend_Mode blend_mode, Render_Pass render_pass, Specular specular, Bump_Mapping bump_mapping, Tinting tinting, bool applyFixes = false)
{
this.albedo = albedo;
this.blend_mode = blend_mode;
this.render_pass = render_pass;
this.specular = specular;
this.bump_mapping = bump_mapping;
this.tinting = tinting;
ApplyFixes = applyFixes;
DecalIsSimple = this.render_pass == Render_Pass.Pre_Lighting && this.bump_mapping == Bump_Mapping.Leave;
TemplateGenerationValid = true;
}
public static ShaderGeneratorResult GenerateShader(
ShaderStage stage,
Albedo albedo,
Bump_Mapping bump_mapping,
Alpha_Test alpha_test,
Specular_Mask specular_mask,
Material_Model material_model,
Environment_Mapping environment_mapping,
Self_Illumination self_illumination,
Blend_Mode blend_mode,
Parallax parallax,
Misc misc,
Distortion distortion,
Soft_fade soft_fade
)
{
if (!HaloShaderGeneratorPrivate.IsBaseDLLLoaded)
{
return(null);
}
Type shadergeneratortype = HaloShaderGeneratorPrivate.HaloShaderGeneratorAssembly.ExportedTypes.Where(t => t.Name == "ShaderGenerator").FirstOrDefault();
if (shadergeneratortype == null)
{
return(null);
}
var result = (byte[])shadergeneratortype.GetMethod("GenerateShader").Invoke(null, new object[] {
stage,
albedo,
bump_mapping,
alpha_test,
specular_mask,
material_model,
environment_mapping,
self_illumination,
blend_mode,
parallax,
misc,
distortion,
soft_fade
});
if (result == null)
{
return(null);
}
return(new ShaderGeneratorResult(result));
}
public CortanaGenerator(byte[] options, bool applyFixes = false)
{
this.albedo = (Albedo)options[0];
this.bump_mapping = (Bump_Mapping)options[1];
this.alpha_test = (Alpha_Test)options[2];
this.material_model = (Material_Model)options[3];
this.environment_mapping = (Environment_Mapping)options[4];
this.warp = (Warp)options[5];
this.lighting = (Lighting)options[6];
this.scanlines = (Scanlines)options[7];
this.transparency = (Transparency)options[8];
ApplyFixes = applyFixes;
TemplateGenerationValid = true;
}
/// <summary>
/// Generator instantiation for method specific shaders.
/// </summary>
public CustomGenerator(Albedo albedo, Bump_Mapping bump_mapping, Alpha_Test alpha_test, Specular_Mask specular_mask, Material_Model material_model,
Environment_Mapping environment_mapping, Self_Illumination self_illumination, Blend_Mode blend_mode, Parallax parallax, Misc misc)
{
this.albedo = albedo;
this.bump_mapping = bump_mapping;
this.alpha_test = alpha_test;
this.specular_mask = specular_mask;
this.material_model = material_model;
this.environment_mapping = environment_mapping;
this.self_illumination = self_illumination;
this.blend_mode = blend_mode;
this.parallax = parallax;
this.misc = misc;
TemplateGenerationValid = true;
}
public CortanaGenerator(Albedo albedo, Bump_Mapping bump_mapping, Alpha_Test alpha_test, Material_Model material_model,
Environment_Mapping environment_mapping, Warp warp, Lighting lighting, Scanlines scanlines, Transparency transparency, bool applyFixes = false)
{
this.albedo = albedo;
this.bump_mapping = bump_mapping;
this.alpha_test = alpha_test;
this.material_model = material_model;
this.environment_mapping = environment_mapping;
this.warp = warp;
this.lighting = lighting;
this.scanlines = scanlines;
this.transparency = transparency;
ApplyFixes = applyFixes;
TemplateGenerationValid = true;
}
public CustomGenerator(byte[] options, bool applyFixes = false)
{
this.albedo = (Albedo)options[0];
this.bump_mapping = (Bump_Mapping)options[1];
this.alpha_test = (Alpha_Test)options[2];
this.specular_mask = (Specular_Mask)options[3];
this.material_model = (Material_Model)options[4];
this.environment_mapping = (Environment_Mapping)options[5];
this.self_illumination = (Self_Illumination)options[6];
this.blend_mode = (Blend_Mode)options[7];
this.parallax = (Parallax)options[8];
this.misc = (Misc)options[9];
//ApplyFixes = applyFixes;
TemplateGenerationValid = true;
}
public static byte[] GenerateShader(
ShaderStage stage,
Albedo albedo,
Bump_Mapping bump_mapping,
Alpha_Test alpha_test,
Specular_Mask specular_mask,
Material_Model material_model,
Environment_Mapping environment_mapping,
Self_Illumination self_illumination,
Blend_Mode blend_mode,
Parallax parallax,
Misc misc,
Distortion distortion,
Soft_fade soft_fade
)
{
string template = $"shader.hlsl";
List <D3D.SHADER_MACRO> macros = new List <D3D.SHADER_MACRO>();
switch (stage)
{
//case ShaderStage.Default:
case ShaderStage.Albedo:
//case ShaderStage.Static_Per_Pixel:
//case ShaderStage.Static_Per_Vertex:
//case ShaderStage.Static_Sh:
case ShaderStage.Static_Prt_Ambient:
case ShaderStage.Static_Prt_Linear:
case ShaderStage.Static_Prt_Quadratic:
//case ShaderStage.Dynamic_Light:
//case ShaderStage.Shadow_Generate:
case ShaderStage.Active_Camo:
//case ShaderStage.Lightmap_Debug_Mode:
//case ShaderStage.Static_Per_Vertex_Color:
//case ShaderStage.Dynamic_Light_Cinematic:
//case ShaderStage.Sfx_Distort:
break;
default:
return(null);
}
// prevent the definition helper from being included
macros.Add(new D3D.SHADER_MACRO {
Name = "_DEFINITION_HELPER_HLSLI", Definition = "1"
});
macros.AddRange(ShaderGeneratorBase.CreateMethodEnumDefinitions <ShaderStage>());
macros.AddRange(ShaderGeneratorBase.CreateMethodEnumDefinitions <ShaderType>());
macros.AddRange(ShaderGeneratorBase.CreateMethodEnumDefinitions <Albedo>());
macros.AddRange(ShaderGeneratorBase.CreateMethodEnumDefinitions <Bump_Mapping>());
macros.AddRange(ShaderGeneratorBase.CreateMethodEnumDefinitions <Alpha_Test>());
macros.AddRange(ShaderGeneratorBase.CreateMethodEnumDefinitions <Specular_Mask>());
macros.AddRange(ShaderGeneratorBase.CreateMethodEnumDefinitions <Material_Model>());
macros.AddRange(ShaderGeneratorBase.CreateMethodEnumDefinitions <Environment_Mapping>());
macros.AddRange(ShaderGeneratorBase.CreateMethodEnumDefinitions <Self_Illumination>());
macros.AddRange(ShaderGeneratorBase.CreateMethodEnumDefinitions <Blend_Mode>());
macros.AddRange(ShaderGeneratorBase.CreateMethodEnumDefinitions <Parallax>());
macros.AddRange(ShaderGeneratorBase.CreateMethodEnumDefinitions <Misc>());
macros.Add(ShaderGeneratorBase.CreateMacro("calc_albedo_ps", albedo, "calc_albedo_", "_ps"));
if (albedo == Albedo.Constant_Color)
{
macros.Add(ShaderGeneratorBase.CreateMacro("calc_albedo_vs", albedo, "calc_albedo_", "_vs"));
}
macros.Add(ShaderGeneratorBase.CreateMacro("calc_bumpmap_ps", bump_mapping, "calc_bumpmap_", "_ps"));
macros.Add(ShaderGeneratorBase.CreateMacro("calc_bumpmap_vs", bump_mapping, "calc_bumpmap_", "_vs"));
macros.Add(ShaderGeneratorBase.CreateMacro("calc_alpha_test_ps", alpha_test, "calc_alpha_test_", "_ps"));
macros.Add(ShaderGeneratorBase.CreateMacro("calc_specular_mask_ps", specular_mask, "calc_specular_mask_", "_ps"));
macros.Add(ShaderGeneratorBase.CreateMacro("calc_self_illumination_ps", self_illumination, "calc_self_illumination_", "_ps"));
macros.Add(ShaderGeneratorBase.CreateMacro("calc_parallax_ps", parallax, "calc_parallax_", "_ps"));
switch (parallax)
{
case Parallax.Simple_Detail:
macros.Add(ShaderGeneratorBase.CreateMacro("calc_parallax_vs", Parallax.Simple, "calc_parallax_", "_vs"));
break;
default:
macros.Add(ShaderGeneratorBase.CreateMacro("calc_parallax_vs", parallax, "calc_parallax_", "_vs"));
break;
}
macros.Add(ShaderGeneratorBase.CreateMacro("material_type", material_model, "material_type_"));
macros.Add(ShaderGeneratorBase.CreateMacro("envmap_type", environment_mapping, "envmap_type_"));
macros.Add(ShaderGeneratorBase.CreateMacro("blend_type", blend_mode, "blend_type_"));
macros.Add(ShaderGeneratorBase.CreateMacro("shaderstage", stage, "shaderstage_"));
macros.Add(ShaderGeneratorBase.CreateMacro("shadertype", stage, "shadertype_"));
macros.Add(ShaderGeneratorBase.CreateMacro("albedo_arg", albedo, "k_albedo_"));
macros.Add(ShaderGeneratorBase.CreateMacro("self_illumination_arg", self_illumination, "k_self_illumination_"));
macros.Add(ShaderGeneratorBase.CreateMacro("material_type_arg", material_model, "k_material_model_"));
macros.Add(ShaderGeneratorBase.CreateMacro("envmap_type_arg", environment_mapping, "k_environment_mapping_"));
macros.Add(ShaderGeneratorBase.CreateMacro("blend_type_arg", blend_mode, "k_blend_mode_"));
var shader_bytecode = ShaderGeneratorBase.GenerateSource(template, macros, "entry_" + stage.ToString().ToLower(), "ps_3_0");
return(shader_bytecode);
}
bool RegenerateShader(
RenderMethodTemplate rmt2,
PixelShader pixl,
int[] shader_args,
ShaderType type,
ShaderStage shaderstage,
RenderMethodTemplate.ShaderModeBitmask bit,
RenderMethodTemplate.ShaderMode mode
)
{
MethodInfo method = null;
switch (type)
{
case ShaderType.Shader:
method = typeof(HaloShaderGenerator.HaloShaderGenerator).GetMethod("GenerateShader");
break;
case ShaderType.Cortana:
method = typeof(HaloShaderGenerator.HaloShaderGenerator).GetMethod("GenerateShaderCortana");
break;
default:
return(false);
}
if (method == null)
{
return(false);
}
//TODO: Rewrite this crazyness
if ((rmt2.DrawModeBitmask | bit) != 0)
{
if (HaloShaderGenerator.HaloShaderGenerator.IsShaderSuppored(type, shaderstage))
{
var GenerateShaderArgs = CreateArguments(method, shaderstage, shader_args);
//TODO: Remove this
switch (shaderstage)
{
case ShaderStage.Albedo:
Albedo albedo = GenerateShaderArgs.Where(x => x.GetType() == typeof(Albedo)).Cast <Albedo>().FirstOrDefault();
if (albedo > Albedo.Two_Detail_Black_Point)
{
return(false); // saber territory
}
Bump_Mapping bumpmapping = GenerateShaderArgs.Where(x => x.GetType() == typeof(Bump_Mapping)).Cast <Bump_Mapping>().FirstOrDefault();
if (bumpmapping > Bump_Mapping.Detail)
{
return(false); // saber territory
}
break;
}
var shaderGeneratorResult = method.Invoke(null, GenerateShaderArgs) as HaloShaderGenerator.ShaderGeneratorResult;
if (shaderGeneratorResult?.Bytecode == null)
{
return(false);
}
var offset = pixl.DrawModes[(int)mode].Offset;
var count = pixl.DrawModes[(int)mode].Count;
var pixelShaderBlock = Porting.PortTagCommand.GeneratePixelShaderBlock(CacheContext, shaderGeneratorResult);
pixl.Shaders[offset] = pixelShaderBlock;
rmt2.DrawModeBitmask |= bit;
return(true);
}
// todo, disable it. but for now, we'll just keep the other shaders here
}
return(false);
}
