test_tag.h

Go to the documentation of this file.

// test_tag [ttag] - Tag Definition                  //
// --------                                         //
// Author: haloman30                               //
// Revision: 5                                    //
// --------                                      //
// 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_ttag "ttag"
 
 
 
#pragma pack(push, 1)
struct test_tag
{
    int32_t integer_test; 
    int16_t short_test; 
    int8_t byte_test; 
 
    TAG_BLOCK(block_test,
    {
        int16_t width; 
        int16_t height; 
        int8_t depth; 
        struct bitfield8_format_flags
        {
            bool bit_0 : 1;
            bool bit_1 : 1;
            bool bit_2 : 1;
            bool is_tiled : 1;
            bool unused4 : 1;
            bool unused5 : 1;
            bool unused6 : 1;
            bool unused7 : 1;
        };
 
        bitfield8_format_flags format_flags; 
 
        TAG_ENUM(type,
        {
            _2d_texture,
            _3d_texture,
            cubemap,
            unknown,
        });
 
        int32_t hidden_child_field;
    });
    TAG_BLOCK(the_go_fuck_yourself_block,
    {        struct bitfield16_extra_flags
        {
            bool can_you_imagine_needing_this_many_flags : 1;
            bool yea_me_neither : 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_extra_flags extra_flags; 
        struct bitfield32_who_needs_this_many_fucking_flags
        {
            bool enable_diffusion_dithering : 1;
            bool disable_height_map_compression : 1;
            bool uniform_sprite_sequences : 1;
            bool filthy_sprite_bug_fix : 1;
            bool use_sharp_bump_filter : 1;
            bool unused : 1;
            bool use_clampedmirrored_bump : 1;
            bool invert_detail_fade : 1;
            bool swap_x_y_vector_components : 1;
            bool convert_from_signed : 1;
            bool convert_to_signed : 1;
            bool import_mipmap_chains : 1;
            bool intentionally_true_color : 1;
            bool unused13 : 1;
            bool unused14 : 1;
            bool unused15 : 1;
            bool unused16 : 1;
            bool unused17 : 1;
            bool unused18 : 1;
            bool unused19 : 1;
            bool unused20 : 1;
            bool unused21 : 1;
            bool unused22 : 1;
            bool unused23 : 1;
            bool unused24 : 1;
            bool unused25 : 1;
            bool unused26 : 1;
            bool unused27 : 1;
            bool unused28 : 1;
            bool unused29 : 1;
            bool unused30 : 1;
            bool unused31 : 1;
        };
 
        bitfield32_who_needs_this_many_fucking_flags who_needs_this_many_fucking_flags; 
    });
    TAG_BLOCK(nested_block_test,
    {
        int32_t nested_property;
        data_reference nested_string;
        TAG_BLOCK(child_block,
        {
            int16_t please_work;
            data_reference nested_string1;
            TAG_ENUM(argh,
            {
                on_e,
                two,
                thr__e__e,
                _4,
            });
 
            data_reference nested_string2;
            data_reference test_dataref; 
        });
    });
    data_reference test_dataref; 
    int32_t int32_field_0;
    TAG_BLOCK(block,
    {
        int32_t integer;
        data_reference dataref;
        TAG_BLOCK(block_two,
        {
            int32_t integer;
            data_reference dataref;
            TAG_BLOCK(block_three,
            {
                int32_t integer;
                data_reference dataref;
                TAG_BLOCK(block_four,
                {
                    int32_t integer;
                    data_reference dataref;
                    TAG_BLOCK(block_five,
                    {
                        int32_t integer;
                        data_reference dataref;
                    });
                });
            });
        });
    });
    int32_t another_int;
    field_reference fieldref_field_0;
    TAG_BLOCK(hidden_tag_block,
    {
        int32_t yeah;
    });
    real hidden_real;
    data_reference dataref_field_0;
    tag_reference tagref_field_1;
    color color_field_2;
    color color_field_1;
    data_reference dataref_no_direct_edit;
};
#pragma pack(pop)
 
class TestTagTagClass : public BlamTagClass
{
public:
    TestTagTagClass()
    {
        class_name_long = "test_tag";
        class_name_short = "ttag";
        version = 5;
 
        revisions = {
            {1, "haloman30", "Initial implementation."},
            {2, "haloman30", "Move over test fields that were in bitmap tag for some reason"},
            {3, "haloman30", "* Added hidden tag block and hidden real fields"},
            {4, "haloman30", "* Added hidden dataref, tagref, and color fields\n\n            * Added hidden test field to "},
            {5, "haloman30", "* Add dataref with direct editing disabled"},
 
        };
 
        tag_size = 335;
 
        fields =
        {
            new CommentField("test tag",
            "this tag class is used for testing purposes only, do not use it for actual game data"),
            new CommentField("Bitmap",
            "im gonna shove a bitmap up your ass"),
            new Int32Field("integer test", "memes"),
            new Int16Field("short test", "A short has a length of 2 bytes."),
            new Int8Field("byte test", "A byte has a length of 1 bytes."),
            new BlockField(14, "block test", "*sweats nervously*",
            {
                new Int16Field("width", "image width"),
                new Int16Field("height", "image height"),
                new Int8Field("depth", "image depth"),
                new CommentField("comment title",
                "explanation goes here brotheR"),
                new Bitfield8Field("format flags", "extra flags for fuck you",
                {
                    "bit 0",
                    "bit 1",
                    "bit 2",
                    "is tiled",
                }),
                new Enum32Field("type", "the usage type of this bitmap",
                {
                    "2d texture",
                    "3d texture",
                    "cubemap",
                    "unknown",
                }),
                new Int32Field("hidden child field", ""),
            }),
            new BlockField(6, "the 'go fuck yourself' block", "yea im tired leave me alone",
            {
                new Bitfield16Field("extra flags", "hi",
                {
                    "can you imagine needing this many flags",
                    "yea me neither",
                }),
                new Bitfield32Field("who needs this many fucking flags", "apparently me because i put this shit here",
                {
                    "enable diffusion dithering",
                    "disable height map compression",
                    "uniform sprite sequences",
                    "filthy sprite bug fix",
                    "use sharp bump filter",
                    "UNUSED",
                    "use clamped/mirrored bump",
                    "invert detail fade",
                    "swap x-y vector components",
                    "convert from signed",
                    "convert to signed",
                    "import mipmap chains",
                    "intentionally true color",
                }),
            }),
            new BlockField(68, "nested block test", "testing block nesting",
            {
                new Int32Field("nested property", ""),
                new DataReferenceField("nested string", ""),
                new BlockField(102, "child block", "",
                {
                    new Int16Field("please work", ""),
                    new DataReferenceField("nested string1", ""),
                    new Enum32Field("argh", "second enum test",
                    {
                        "ON E",
                        "tWo",
                        "thR  e  E",
                        "4",
                    }),
                    new DataReferenceField("nested string2", ""),
                    new DataReferenceField("test dataref", "testing data reference"),
                }),
            }),
            new DataReferenceField("test dataref", "testing data reference"),
            new CommentField("Normal Comment",
            "normal, unstyled comment"),
            new CommentField("Info Comment",
            "key information"),
            new CommentField("Warning Comment",
            "warning message"),
            new CommentField("Error Comment",
            "error message"),
            new Int32Field("int32 field 0", ""),
            new BlockField(68, "block", "",
            {
                new Int32Field("integer", ""),
                new DataReferenceField("dataref", ""),
                new BlockField(68, "block two", "",
                {
                    new Int32Field("integer", ""),
                    new DataReferenceField("dataref", ""),
                    new BlockField(68, "block three", "",
                    {
                        new Int32Field("integer", ""),
                        new DataReferenceField("dataref", ""),
                        new BlockField(68, "block four", "",
                        {
                            new Int32Field("integer", ""),
                            new DataReferenceField("dataref", ""),
                            new BlockField(36, "block five", "",
                            {
                                new Int32Field("integer", ""),
                                new DataReferenceField("dataref", ""),
                            }),
                        }),
                    }),
                }),
            }),
            new Int32Field("another int", ""),
            new FieldReferenceField("fieldref field 0", ""),
            new BlockField(4, "hidden tag block", "",
            {
                new Int32Field("yeah", ""),
            }),
            new RealField("hidden real", ""),
            new DataReferenceField("dataref field 0", ""),
            new TagReferenceField("tagref field 1", "", { }),
            new ColorField("color field 2", ""),
            new ColorField("color field 1", ""),
            new CommentField("balls",
            ""),
            new DataReferenceField("dataref no direct edit", ""),
 
        };
    }
};
 
namespace Blam::Content::Tags
{
    BLAM test_tag* GetTestTagTag(std::string tag_path);
}