예제 #1
0
 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
                         )));
 }
예제 #2
0
        public FoliageGenerator(byte[] options, bool applyFixes = false)
        {
            this.albedo         = (Albedo)options[0];
            this.alpha_test     = (Alpha_Test)options[1];
            this.material_model = (Material_Model)options[2];

            ApplyFixes = applyFixes;
            TemplateGenerationValid = true;
        }
예제 #3
0
        /// <summary>
        /// Generator instantiation for method specific shaders.
        /// </summary>
        public FoliageGenerator(Albedo albedo, Alpha_Test alpha_test, Material_Model material_model, bool applyFixes = false)
        {
            this.albedo         = albedo;
            this.alpha_test     = alpha_test;
            this.material_model = material_model;

            ApplyFixes = applyFixes;
            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));
        }
예제 #5
0
        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;
        }
예제 #6
0
 /// <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;
 }
예제 #7
0
        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;
        }
예제 #8
0
        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;
        }
예제 #9
0
        private List <Material_Model> CreateMaterialKeeper(IRfcTable rtb)
        {
            List <Material_Model> lstMaterialKeeper = new List <Material_Model>();

            if (rtb != null && rtb.Count > 0)
            {
                foreach (var itemRtb in rtb)
                {
                    Material_Model item = new Material_Model();
                    item.MaterialNo         = itemRtb.GetString("MATNR");
                    item.MaterialDesc       = itemRtb.GetString("MAKTX");
                    item.MaterialKeeperNo   = itemRtb.GetString("ZCNUM");
                    item.MaterialLeeperName = itemRtb.GetString("ZCNAME");
                    item.StorageLoc         = itemRtb.GetString("LGORT");
                    lstMaterialKeeper.Add(item);
                }
            }
            return(lstMaterialKeeper);
        }
예제 #10
0
        private List <Material_Model> CreateIsRoshDeliveryDetailsMaterial(IRfcTable rtb)
        {
            List <Material_Model> lstMaterial = null;

            if (rtb.RowCount > 0)
            {
                lstMaterial = new List <Material_Model>();
            }
            foreach (var itemRtb in rtb)
            {
                Material_Model item = new Material_Model();
                item.VoucherNo  = itemRtb.GetString("EBELN");
                item.RowNo      = itemRtb.GetString("EBELP");
                item.MaterialNo = itemRtb.GetString("MATNR");
                item.ROHS       = itemRtb.GetString("RFLAG");
                lstMaterial.Add(item);
            }
            return(lstMaterial);
        }
예제 #11
0
        private List <Material_Model> CreateIsRoshDeliveryDetailsMaterial(IRfcTable rtb)
        {
            List <Material_Model> lstMaterial = null;

            if (rtb.RowCount > 0)
            {
                lstMaterial = new List <Material_Model>();
            }
            foreach (var itemRtb in rtb)
            {
                Material_Model item = new Material_Model();
                item.MaterialNo   = itemRtb.GetString("MATNR");
                item.MaterialDesc = itemRtb.GetString("MAKTX");
                item.Unit         = itemRtb.GetString("MEINS");
                item.ROHS         = itemRtb.GetString("NORMT");

                lstMaterial.Add(item);
            }
            return(lstMaterial);
        }
예제 #12
0
        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);
        }