shader.h

Go to the documentation of this file.

// shader [rmsh] - Tag Definition                 //
// --------                                      //
// 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
 
#define tag_rmsh "rmsh"
 
enum class shader_parameter_type : uint8_t
{
    float1,
    float2,
    float3,
    float4,
};
 
 
#pragma pack(push, 1)
struct shader
{
    TAG_ENUM8(shader_method,
    {
        raw,
        pbs,
    });
 
    struct bitfield16_flags
    {
        bool prefer_referenced_programs : 1;
        bool unused1 : 1;
        bool unused2 : 1;
        bool unused3 : 1;
        bool unused4 : 1;
        bool unused5 : 1;
        bool unused6 : 1;
        bool unused7 : 1;
        bool unused8 : 1;
        bool unused9 : 1;
        bool unused10 : 1;
        bool unused11 : 1;
        bool unused12 : 1;
        bool unused13 : 1;
        bool unused14 : 1;
        bool unused15 : 1;
    };
 
    bitfield16_flags flags; 
    tag_reference vertex_program;
    tag_reference pixel_program;
    tag_reference geometry_program;
    tag_reference hull_program;
    tag_reference domain_program;
    tag_reference compute_program;
    TAG_BLOCK(programs,
    {
        TAG_ENUM8(type,
        {
            vertex,
            pixel,
            geometry,
            hull,
            domain,
            compute,
        });
 
        data_reference syntax_code;
        data_reference target;
        data_reference entry_point;
        data_reference program;
    });
    TAG_ENUM8(shader_type,
    {
        universal,
    });
 
    TAG_BLOCK(global_parameters,
    {
    });
    TAG_BLOCK(instance_parameters,
    {
        shader_parameter_type type;
        struct bitfield8_flags
        {
            bool is_array : 1;
            bool pass_to_pixel_shader : 1;
            bool unused2 : 1;
            bool unused3 : 1;
            bool unused4 : 1;
            bool unused5 : 1;
            bool unused6 : 1;
            bool unused7 : 1;
        };
 
        bitfield8_flags flags; 
        data_reference name;
        int32_t array_size;
    });
    data_reference source;
};
#pragma pack(pop)
 
class ShaderTagClass : public BlamTagClass
{
public:
    ShaderTagClass()
    {
        class_name_long = "shader";
        class_name_short = "rmsh";
        version = 0;
 
        revisions = {
 
        };
 
        tag_size = 324;
 
        fields =
        {
            new Enum8Field("shader method", "",
            {
                "raw",
                "pbs",
            }),
            new Bitfield16Field("flags", "",
            {
                "prefer referenced programs",
            }),
            new CommentField("[raw] shader programs",
            "The parameters listed below are only valid when shader method is set to \"raw\". This approach allows direct creation of shader programs and does not include any additional code or functionality offered with PBR or Unlit materials."),
            new TagReferenceField("vertex program", "", { "rmsp"}),
            new TagReferenceField("pixel program", "", { }),
            new TagReferenceField("geometry program", "", { "rmsp"}),
            new TagReferenceField("hull program", "", { }),
            new TagReferenceField("domain program", "", { }),
            new TagReferenceField("compute program", "", { }),
            new BlockField(129, "programs", "",
            {
                new Enum8Field("type", "",
                {
                    "vertex",
                    "pixel",
                    "geometry",
                    "hull",
                    "domain",
                    "compute",
                }),
                new DataReferenceField("syntax code", ""),
                new DataReferenceField("target", ""),
                new DataReferenceField("entry point", ""),
                new DataReferenceField("program", ""),
            }),
            new CommentField("$$$ WARNING",
            "The fields below are used only for using shaders which directly extend from PBR materials. While functional, they are also more error-prone and shader errors can (and often will) result in outright engine crashes.\n"
            "\n"
            "You are strongly encouraged to *only* use standalone shader programs as outlined above. If you experience performance problems using them with many objects, you may use the below shader approach - however this functionality may be removed outright in the future."),
            new CommentField("[pbr] shader config",
            "The parameters listed below are only valid when shader method is set to \"pbr\". This approach aims to offer the same functionality as raw shaders, but does so while basing off of PBR materials, allowing some additional functionality out of the box."),
            new Enum8Field("shader type", "",
            {
                "universal",
            }),
            new BlockField(0, "global parameters", "",
            {
            }),
            new BlockField(38, "instance parameters", "",
            {
                new Enum8Field("type", "",
                {
                    "float1",
                    "float2",
                    "float3",
                    "float4",
                }),
                new Bitfield8Field("flags", "",
                {
                    "is array",
                    "pass to pixel shader",
                }),
                new DataReferenceField("name", ""),
                new Int32Field("array size", ""),
            }),
            new DataReferenceField("source", ""),
 
        };
    }
};
 
namespace Blam::Content::Tags
{
    BLAM shader* GetShaderTag(std::string tag_path);
}