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
)));
}
/// <summary>
/// Generator instantiation for method specific shaders.
/// </summary>
public LightVolumeGenerator(Albedo albedo, Blend_Mode blend_mode, Fog fog, bool applyFixes = false)
{
this.albedo = albedo;
this.blend_mode = blend_mode;
this.fog = fog;
ApplyFixes = applyFixes;
TemplateGenerationValid = true;
}
public LightVolumeGenerator(byte[] options, bool applyFixes = false)
{
this.albedo = (Albedo)options[0];
this.blend_mode = (Blend_Mode)options[1];
this.fog = (Fog)options[2];
ApplyFixes = applyFixes;
TemplateGenerationValid = true;
}
public BeamGenerator(byte[] options, bool applyFixes = false)
{
this.albedo = (Albedo)options[0];
this.blend_mode = (Blend_Mode)options[1];
this.black_point = (Black_Point)options[2];
this.fog = (Fog)options[3];
ApplyFixes = applyFixes;
TemplateGenerationValid = true;
}
/// <summary>
/// Generator instantiation for method specific shaders.
/// </summary>
public BeamGenerator(Albedo albedo, Blend_Mode blend_mode, Black_Point black_point, Fog fog, bool applyFixes = false)
{
this.albedo = albedo;
this.blend_mode = blend_mode;
this.black_point = black_point;
this.fog = fog;
ApplyFixes = applyFixes;
TemplateGenerationValid = true;
}
public ScreenGenerator(byte[] options, bool applyFixes = false)
{
this.warp = (Warp)options[0];
this._base = (Base)options[1];
this.overlay_a = (Overlay_A)options[2];
this.overlay_b = (Overlay_B)options[3];
this.blend_mode = (Blend_Mode)options[4];
ApplyFixes = applyFixes;
TemplateGenerationValid = true;
}
/// <summary>
/// Generator instantiation for method specific shaders.
/// </summary>
public ScreenGenerator(Warp warp, Base _base, Overlay_A overlay_a, Overlay_B overlay_b, Blend_Mode blend_mode, bool applyFixes = false)
{
this.warp = warp;
this._base = _base;
this.overlay_a = overlay_a;
this.overlay_b = overlay_b;
this.blend_mode = blend_mode;
ApplyFixes = applyFixes;
TemplateGenerationValid = true;
}
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));
}
/// <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 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 ParticleGenerator(byte[] options, bool applyFixes = false)
{
this.albedo = (Albedo)options[0];
this.blend_mode = (Blend_Mode)options[1];
this.specialized_rendering = (Specialized_Rendering)options[2];
this.lighting = (Lighting)options[3];
this.render_targets = (Render_Targets)options[4];
this.depth_fade = (Depth_Fade)options[5];
this.black_point = (Black_Point)options[6];
this.fog = (Fog)options[7];
this.frame_blend = (Frame_Blend)options[8];
this.self_illumination = (Self_Illumination)options[9];
ApplyFixes = applyFixes;
TemplateGenerationValid = true;
}
/// <summary>
/// Generator instantiation for method specific shaders.
/// </summary>
public ParticleGenerator(Albedo albedo, Blend_Mode blend_mode, Specialized_Rendering specialized_rendering, Lighting lighting, Render_Targets render_targets,
Depth_Fade depth_fade, Black_Point black_point, Fog fog, Frame_Blend frame_blend, Self_Illumination self_illumination, bool applyFixes = false)
{
this.albedo = albedo;
this.blend_mode = blend_mode;
this.specialized_rendering = specialized_rendering;
this.lighting = lighting;
this.render_targets = render_targets;
this.depth_fade = depth_fade;
this.black_point = black_point;
this.fog = fog;
this.frame_blend = frame_blend;
this.self_illumination = self_illumination;
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);
}
