test_tag.h

Go to the documentation of this file.

// test_tag [ttag] - 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
 
 
 
#pragma pack(push, 1)
struct test_tag
{
    //test tag
    /*this tag class is used for testing purposes only, do not use it for actual game data*/
    //Bitmap
    /*im gonna shove a bitmap up your ass*/
    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; 
        //comment title
        /*explanation goes here brotheR*/
        bitfield8 format_flags; 
 
        TAG_ENUM(type,
        {
            _2d_texture,
            _3d_texture,
            cubemap,
            unknown,
        });
 
    });
    TAG_BLOCK(the_go_fuck_yourself_block,
    {
        bitfield16 extra_flags; 
        bitfield32 who_needs_this_many_fucking_flags; 
    });
    TAG_BLOCK(nested_block_test,
    {
        int32_t nested_property;
        ascii nested_string;
        TAG_BLOCK(child_block,
        {
            int16_t please_work;
            ascii nested_string1;
            TAG_ENUM(argh,
            {
                on_e,
                two,
                thr__e__e,
                _4,
            });
 
            ascii nested_string2;
            data_reference test_dataref; 
        });
    });
    data_reference test_dataref; 
    //Normal Comment
    /*normal, unstyled comment*/
    //Info Comment
    /*key information*/
    //Warning Comment
    /*warning message*/
    //Error Comment
    /*error message*/
    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;
};
#pragma pack(pop)
 
class TestTagTagClass : public BlamTagClass
{
public:
    TestTagTagClass()
    {
        class_name_long = "test_tag";
        class_name_short = "ttag";
        version = 2;
 
        revisions = {
            {1, "haloman30", "Initial implementation."},
            {2, "haloman30", "Move over test fields that were in bitmap tag for some reason"},
 
        };
 
        tag_size = 191;
 
        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(10, "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 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(164, "nested block test", "testing block nesting",
            {
                new Int32Field("nested property", ""),
                new AsciiField("nested string", ""),
                new BlockField(294, "child block", "",
                {
                    new Int16Field("please work", ""),
                    new AsciiField("nested string1", ""),
                    new Enum32Field("argh", "second enum test",
                    {
                        "ON E",
                        "tWo",
                        "thR  e  E",
                        "4",
                    }),
                    new AsciiField("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 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", ""),
 
        };
    }
};
 
namespace Blam::Content::Tags
{
    BLAM test_tag* GetTestTagTag(std::string tag_path);
}