light.h

Go to the documentation of this file.

// light [ligh] - Tag Definition                     //
// --------                                         //
// Author: haloman30                               //
// Revision: 2                                    //
// --------                                      //
// 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_ligh "ligh"
 
 
 
#pragma pack(push, 1)
struct light
{
    struct bitfield16_flags
    {
        bool casts_shadows : 1;
        bool double_sided : 1;
        bool fields_can_be_overridden_by_instances : 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; 
    int32_t priority;
    TAG_ENUM(shape,
    {
        directional,
        point,
        spotlight,
        virtual_point,
        area_cheap,
        area_pbr,
    });
 
    real power_scale; 
    color diffuse_color;
    color specular_color;
    real maximum_distance; 
    real near_clip_distance; 
    real far_clip_distance; 
    real near_shadow_distance; 
    real far_shadow_distance; 
    TAG_BLOCK(spotlight_settings,
    {
        real inner_angle;
        real outer_angle;
        real falloff;
        real near_clip_distance;
    });
    TAG_ENUM(attenuation_method,
    {
        simple,
        complex,
    });
 
    TAG_BLOCK(simple_attenuation,
    {
        real radius;
        real luminance_threshold;
    });
    TAG_BLOCK(complex_attenuation,
    {
        real range;
        real constant;
        real linear;
        real quadratic;
    });
};
#pragma pack(pop)
 
class LightTagClass : public BlamTagClass
{
public:
    LightTagClass()
    {
        class_name_long = "light";
        class_name_short = "ligh";
        version = 2;
 
        revisions = {
            {1, "haloman30", "Initial implementation."},
            {2, "haloman30", "* Added priority field"},
 
        };
 
        tag_size = 142;
 
        fields =
        {
            new CommentField("LIGHT",
            ""),
            new Bitfield16Field("flags", "",
            {
                "casts shadows",
                "double sided",
                "fields can be overridden by instances",
            }),
            new Int32Field("priority", ""),
            new CommentField("SHAPE",
            "shape of the light"),
            new Enum32Field("shape", "The shape/type of the light source.",
            {
                "directional",
                "point",
                "spotlight",
                "virtual point",
                "area (cheap)",
                "area (pbr)",
            }),
            new RealField("power scale", "The relative power scale of the light."),
            new CommentField("COLOR",
            "color and intensity of the light"),
            new ColorField("diffuse color", ""),
            new ColorField("specular color", ""),
            new CommentField("CULLING",
            "determines how the light is rendered when the camera is close or far from the light"),
            new RealField("maximum distance", "The maximum distance that this light will be visible. If the camera is further than this distance away from the light, then the light will no longer be rendered."),
            new RealField("near clip distance", "The near clip distance of the light. If the camera is this close to the light, shadows will stop being rendered. Only applies when using texture shadows."),
            new RealField("far clip distance", "The far clip distance of the light. If the camera is at least this far from the light, shadows will stop being rendered. Only applies when using texture shadows."),
            new RealField("near shadow distance", "The near shadow distance of the light. If the camera is this close to the light, shadows will no longer be cast by this light source."),
            new RealField("far shadow distance", "The far shadow distance of the light. If the camera is this far from the light, shadows will no longer be cast by this light source."),
            new BlockField(16, "spotlight settings", "",
            {
                new CommentField("SHAPE",
                "the shape of the spotlight"),
                new RealField("inner angle", ""),
                new RealField("outer angle", ""),
                new CommentField("FALLOFF",
                "the falloff of the spotlight"),
                new RealField("falloff", ""),
                new RealField("near clip distance", ""),
            }),
            new CommentField("ATTENUATION",
            "Controls how light diminishes with distance.\n"
            "\n"
            "Of the two blocks listed below, only one will be used based on the 'attenuation method' value:\n"
            "* simple - The 'simple attenuation' block is used.\n"
            "* complex - The 'complex attenuation' block is used.\n"
            "\n"
            "Only the first entry of a block will be used. Any other entries are ignored."),
            new Enum32Field("attenuation method", "",
            {
                "simple",
                "complex",
            }),
            new BlockField(8, "simple attenuation", "",
            {
                new RealField("radius", ""),
                new RealField("luminance threshold", ""),
            }),
            new BlockField(16, "complex attenuation", "",
            {
                new RealField("range", ""),
                new RealField("constant", ""),
                new RealField("linear", ""),
                new RealField("quadratic", ""),
            }),
 
        };
    }
};
 
namespace Blam::Content::Tags
{
    BLAM light* GetLightTag(std::string tag_path);
}