material.h

Go to the documentation of this file.

// material [mat] - Tag Definition                   //
// --------                                         //
// Author: haloman30                               //
// Revision: 6                                    //
// --------                                      //
// Part of the Blamite Game Engine              //
// Copyright (c) Elaztek Studios 2013 - 2023   //
 
 
#pragma once
 
#include <string>
#include <blam/api/v1/types/tags.h>
#include <blam/api/v1/types/plugins.h>
 
#ifndef BLAM
#define BLAM
#endif
 
enum class material_filter_modes : uint32_t
{
    inherit_from_bitmap,
    none,
    point,
    linear,
    anisotropic,
};
enum class material_wrap_modes : uint32_t
{
    wrap,
    mirror,
    clamp,
    border,
};
enum class material_comparison_function : uint32_t
{
    always_fail,
    always_pass,
    less_than,
    less_than_or_equal,
    equal,
    not_equal,
    greater_than_or_equal,
    greater_than,
    disabled,
};
 
 
#pragma pack(push, 1)
struct material
{
    //Material
    
    ascii id;
    TAG_ENUM(material_type,
    {
        pbr,
        unlit,
    });
 
    TAG_BLOCK(pbr_material,
    {
        bitfield16 flags;
        TAG_BLOCK(textures,
        {
            //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
            
            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
        /*bidirectional reflectance distribution function*/
        bitfield16 brdf_flags;
        TAG_ENUM(brdf_function,
        {
            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;
        //CLEAR COAT
        
        real clear_coat_amount;
        real clear_coat_roughness;
        //TRANSPARENCY
        
        real transparency_amount;
        bitfield16 transparency_flags;
        TAG_ENUM(transparency_mode,
        {
            none,
            transparent,
            fade,
            refractive,
        });
 
        real refraction_strength;
        //WORKFLOWS
        
        TAG_ENUM(workflows,
        {
            specular,
            specular_fresnel,
            metallic,
        });
 
        color specular_color;
        real metalness;
        real roughness;
    });
    TAG_BLOCK(unlit_material,
    {
        bitfield16 flags;
        TAG_BLOCK(textures,
        {
            //TEXTURES
            
            int8_t texture_type;
            tag_reference texture;
            //SAMPLER
            
            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;
            vector2 lod;
            real lod_bias;
            real max_anisotropy;
            vector2 offset;
            vector2 scale;
        });
        color diffuse_color;
        //ALPHA
        
        material_comparison_function alpha_comparison_function;
        bitfield16 alpha_flags;
        real alpha_test_threshold;
    });
    TAG_BLOCK(input_parameters,
    {
        ascii name;
        field_reference output_field;
        bitfield8 flags;
    });
};
#pragma pack(pop)
 
class MaterialTagClass : public BlamTagClass
{
public:
    MaterialTagClass()
    {
        class_name_long = "material";
        class_name_short = "mat";
        version = 6;
 
        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 input parameters block"},
            {6, "haloman30", "Add support for unlit materials"},
 
        };
 
        tag_size = 228;
 
        fields =
        {
            new CommentField("Material",
            ""),
            new AsciiField("id", ""),
            new Enum32Field("material type", "",
            {
                "pbr",
                "unlit",
            }),
            new BlockField(100, "pbr material", "",
            {
                new Bitfield16Field("flags", "",
                {
                    "uses two sided lighting",
                    "receives shadows",
                    "use emissive as lightmap",
                }),
                new BlockField(100, "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", "", { "bitmap"}),
                    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",
                    "disabled",
                }),
                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(48, "unlit material", "",
            {
                new Bitfield16Field("flags", "",
                {
                    "enable planar reflections",
                    "enable diffuse color",
                }),
                new BlockField(89, "textures", "",
                {
                    new CommentField("TEXTURES",
                    ""),
                    new Int8Field("texture type", ""),
                    new TagReferenceField("texture", "", { }),
                    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 Vector2Field("lod", ""),
                    new RealField("lod bias", ""),
                    new RealField("max anisotropy", ""),
                    new Vector2Field("offset", ""),
                    new Vector2Field("scale", ""),
                }),
                new ColorField("diffuse color", ""),
                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",
                    "disabled",
                }),
                new Bitfield16Field("alpha flags", "",
                {
                    "shadow caster only",
                    "use alpha from texture",
                }),
                new RealField("alpha test threshold", ""),
            }),
            new BlockField(149, "input parameters", "",
            {
                new AsciiField("name", ""),
                new FieldReferenceField("output field", ""),
                new Bitfield8Field("flags", "",
                {
                    "enabled",
                }),
            }),
 
        };
    }
};
 
namespace Blam::Content::Tags
{
    BLAM material* GetMaterialTag(std::string tag_path);
}