light.h

Go to the documentation of this file.

// light [ligh] - Tag Definition                     //
// --------                                         //
// Author: haloman30                               //
// Revision: 1                                    //
// --------                                      //
// Part of the Blamite Game Engine              //
// Copyright (c) Elaztek Studios 2013 - 2023   //
 
 
#pragma once
 
#include <string>
#include <blam/components/content/tags/tagclass.h>
#include <blam/components/content/tags/fields.h>
#include <blam/components/content/tags/tags.h>
 
#ifndef BLAM
#define BLAM
#endif
 
 
 
#pragma pack(push, 1)
struct light
{
    //LIGHT
    
    bitfield16 flags;
    //SHAPE
    /*shape of the light*/
    TAG_ENUM(shape,
    {
        directional,
        point,
        spotlight,
        virtual_point,
        area_cheap,
        area_pbr,
    });
 
    real power_scale; 
    //COLOR
    /*color and intensity of the light*/
    color diffuse_color;
    color specular_color;
    //CULLING
    /*determines how the light is rendered when the camera is close or far from the light*/
    real maximum_distance; 
    real near_clip_distance; 
    real far_clip_distance; 
    real near_shadow_distance; 
    real far_shadow_distance; 
    TAG_BLOCK(spotlight_settings,
    {
        //SHAPE
        /*the shape of the spotlight*/
        real inner_angle;
        real outer_angle;
        //FALLOFF
        /*the falloff of the spotlight*/
        real falloff;
        real near_clip_distance;
    });
    //ATTENUATION
    /*Controls how light diminishes with distance.
    
    Of the two blocks listed below, only one will be used based on the 'attenuation method' value:
    * simple - The 'simple attenuation' block is used.
    * complex - The 'complex attenuation' block is used.
    
    Only the first entry of a block will be used. Any other entries are ignored.*/
    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 = 1;
 
        revisions = {
            {1, "haloman30", "Initial implementation."},
 
        };
 
        tag_size = 158;
 
        fields =
        {
            new CommentField("LIGHT",
            ""),
            new Bitfield16Field("flags", "",
            {
                "casts shadows",
                "double sided",
                "fields can be overridden by instances",
            }),
            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(16, "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);
}