material.h

Go to the documentation of this file.

#pragma once
 
#include <blam/components/content/tags/tagclass.h>
#include <blam/components/content/tags/fields.h>
 
#ifndef BLAM
#define BLAM
#endif
 
enum material_filter_modes
{
    mat_fm_use_bitmap_state,
    mat_fm_none,
    mat_fm_point,
    mat_fm_linear,
    mat_fm_anisotropic
};
 
enum material_wrap_modes
{
    mat_wrap_wrap,
    mat_wrap_mirror,
    mat_wrap_clamp,
    mat_wrap_border
};
 
enum material_comparison_function
{
    mat_cmp_always_fail,
    mat_cmp_always_pass,
    mat_cmp_less,
    mat_cmp_less_equal,
    mat_cmp_equal,
    mat_cmp_not_equal,
    mat_cmp_greater_equal,
    mat_cmp_greater,
    mat_cmp_disabled
};
 
#pragma pack(push, 1)
 
struct material
{
    ascii id;
 
    TAG_ENUM(material_type,
    {
        pbr,
        unlit
    });
 
    TAG_BLOCK(unlit_material,
    {
 
    });
 
    TAG_BLOCK(pbr_material,
    {
        bitfield16 flags;
 
        TAG_BLOCK(textures, 
        {
            TAG_ENUM(texture_type,
            {
                diffuse,
                normal,
                specular,
                metallic,
                roughness,
                detail_weight,
                detail_0,
                detail_1,
                detail_2,
                detail_3,
                detail_normal_0,
                detail_normal_1,
                detail_normal_2,
                detail_normal_3,
                emissive,
                reflection
            });
 
            tag_reference texture;
 
            // SAMPLER PROPERTIES
            material_filter_modes filter_mode_min;
            material_filter_modes filter_mode_mag;
            material_filter_modes filter_mode_mip;
 
            material_wrap_modes wrap_mode_x;
            material_wrap_modes wrap_mode_y;
            material_wrap_modes wrap_mode_z;
 
            real lod_bias;
            real max_anisotropy;
 
            material_comparison_function sampler_comparison_function;
 
            color border_color;
            real min_lod;
            real max_lod;
 
            vector2 offset;
            vector2 scale;
        });
 
        // BRDF
 
        bitfield16 brdf_flags;
 
        TAG_ENUM(brdf,
        {
            default_brdf,
            cook_torrance,
            blinn_phong,
        });
 
        // ALPHA
        material_comparison_function alpha_comparison_function;
 
        bitfield16 alpha_flags;
        real alpha_test_threshold;
 
        // COLORS
        color diffuse_color;
        color background_diffuse_color;
        color emissive_color;
 
        // OTHER SHIT
        real clear_coat;
        real clear_coat_roughness;
 
        // TRANSPARENCY
        real transparency;
        bitfield16 transparency_flags;
 
        TAG_ENUM(transparency_mode,
        {
            none,
            transparent,
            fade,
            refractive
        });
 
        real refraction_strength;
 
        // WORKFLOWS
        TAG_ENUM(workflow,
        {
            specular,
            specular_fresnel,
            metallic
        });
 
        color specular_color;
        real metalness;
        real roughness;
 
        
    });
 
    TAG_BLOCK(parameters,
    {
        bitfield8 debugging_flags;
 
        TAG_BLOCK(parameter_list, 
        {
            bitfield16 input_flags;
            ascii input_name;
 
            bitfield16 output_flags;
 
            TAG_ENUM(output_type,
            {
                material_property,
                function
            });
 
            ascii output_field_id;
        });
    });
 
    TAG_BLOCK(functions,
    {
 
    });
};
#pragma pack(pop)
 
class MaterialTagClass : public BlamTagClass
{
public:
    MaterialTagClass()
    {
        class_name_long = "material";
        class_name_short = "mat";
        version = 5;
 
        revisions = {
            {1, "haloman30", "Initial implementation."},
            {2, "haloman30", "Add settings for texture sampler."},
            {3, "haloman30", "Combine sampler and texture fields into tag block, with each entry specifying a texture."},
            {4, "haloman30", "Add fields for texture offset and scale."},
            {5, "haloman30", "Add block for parameters, and empty blocks for unlit material and functions"}
        };
 
        tag_size = sizeof(material);
 
        fields =
        {
            new CommentField("Material", ""),
 
            new AsciiField("id", ""),
            new Enum32Field("material type", "",
            {
                "pbr",
                "unlit"
            }),
 
            new BlockField(sizeof(material::unlit_material_entry), "unlit material", "", {}),
 
            new BlockField(sizeof(material::pbr_material_entry), "pbr material", "",
            {
                new Bitfield16Field("", "",
                {
                    "uses two sided lighting",
                    "receives shadows",
                    "use emissive as lightmap"
                }),
 
                new BlockField(sizeof(material::pbr_material_entry::textures_entry), "textures", "", 
                {
                    new CommentField("TEXTURES", ""),
                    new Enum32Field("texture type", "", 
                    {
                        "diffuse",
                        "normal",
                        "specular",
                        "metallic",
                        "roughness",
                        "detail_weight",
                        "detail_0",
                        "detail_1",
                        "detail_2",
                        "detail_3",
                        "detail_normal_0",
                        "detail_normal_1",
                        "detail_normal_2",
                        "detail_normal_3",
                        "emissive",
                        "reflection"
                    }),
                    new TagReferenceField("texture", "", { "bitm" }),
 
                    new CommentField("SAMPLER", ""),
                    new Enum32Field("filter mode (min)", "",
                    {
                        "inherit from bitmap",
                        "none",
                        "point",
                        "linear",
                        "anisotropic"
                    }),
                    new Enum32Field("filter mode (mag)", "",
                    {
                        "inherit from bitmap",
                        "none",
                        "point",
                        "linear",
                        "anisotropic"
                    }),
                    new Enum32Field("filter mode (mip)", "",
                    {
                        "inherit from bitmap",
                        "none",
                        "point",
                        "linear",
                        "anisotropic"
                    }),
                    new Enum32Field("wrap mode x", "",
                    {
                        "wrap",
                        "mirror",
                        "clamp",
                        "border"
                    }),
                    new Enum32Field("wrap mode y", "",
                    {
                        "wrap",
                        "mirror",
                        "clamp",
                        "border"
                    }),
                    new Enum32Field("wrap mode z", "",
                    {
                        "wrap",
                        "mirror",
                        "clamp",
                        "border"
                    }),
                    new RealField("lod bias", ""),
                    new RealField("max anisotropy", ""),
                    new Enum32Field("sampler comparison function", "",
                    {
                        "always fail",
                        "always pass",
                        "less than",
                        "less than or equal",
                        "equal",
                        "not equal",
                        "greater than or equal",
                        "greater than",
                        "disabled"
                    }),
                    new ColorField("border color", ""),
                    new RealField("min lod", ""),
                    new RealField("max lod", ""),
                    new Vector2Field("offset", ""),
                    new Vector2Field("scale", "")
                }),
 
                new CommentField("BRDF", "bidirectional reflectance distribution function"),
                new Bitfield16Field("brdf flags", "",
                {
                    "uncorrelated",
                    "separate diffuse fresnel",
                    "legacy math",
                    "full legacy"
                }),
                new Enum32Field("brdf function", "",
                {
                    "default",
                    "cook-torrance",
                    "blinn-phong"
                }),
 
                new CommentField("ALPHA", ""),
                new Enum32Field("alpha comparison function", "",
                {
                    "always fail",
                    "always pass",
                    "less than",
                    "less than or equal",
                    "equal",
                    "not equal",
                    "greater than or equal",
                    "greater than"
                }),
                new Bitfield16Field("alpha flags", "",
                {
                    "shadow caster only",
                    "use alpha from texture"
                }),
                new RealField("alpha test threshold", ""),
 
                new CommentField("COLORS", ""),
                new ColorField("diffuse color", ""),
                new ColorField("background diffuse color", ""),
                new ColorField("emissive color", ""),
 
 
                new CommentField("CLEAR COAT", ""),
                new RealField("clear coat amount", ""),
                new RealField("clear coat roughness", ""),
 
                new CommentField("TRANSPARENCY", ""),
                new RealField("transparency amount", ""),
                new Bitfield16Field("transparency flags", "",
                {
                    "use alpha from textures",
                    "change blend block"
                }),
                new Enum32Field("transparency mode", "",
                {
                    "none",
                    "transparent",
                    "fade",
                    "refractive"
                }),
                new RealField("refraction strength", ""),
 
                new CommentField("WORKFLOWS", ""),
                new Enum32Field("workflows", "",
                {
                    "specular",
                    "specular (fresnel)",
                    "metallic"
                }),
                new ColorField("specular color", ""),
                new RealField("metalness", ""),
                new RealField("roughness", ""),
 
                
            }),
 
            new BlockField(sizeof(material::parameters_entry), "parameters", "", 
            {
                new Bitfield8Field("debugging flags", "", 
                {
                    "ignore all inputs"
                }),
 
                new BlockField(sizeof(material::parameters_entry::parameter_list_entry), "parameter list", "", 
                {
                    new CommentField("INPUT OPTIONS", "These options determine what can provide inputs "
                        "to the material, and how they can do so."),
 
                    new Bitfield16Field("input flags", "",
                    {
                        "block input from objects",
                        "block input from ui",
                        "block input from scripts"
                    }),
                    new AsciiField("", ""),
 
                    new CommentField("OUTPUT OPTIONS", "These options determine where the parameter is output to, be "
                        "it directly to a property within the material, or to a function for additional processing."),
 
                    new Bitfield16Field("output flags", "",
                    {
                        "unused"
                    }),
                    new Enum32Field("", "", 
                    {
                        "material property",
                        "function"
                    }),
                    new AsciiField("", ""),
                }),
            }),
 
            new BlockField(sizeof(material::functions_entry), "functions", "", {})
        };
    }
};
 
namespace Blam::Content::Tags
{
    BLAM material* GetMaterialTag(std::string tag_path);
}