test_tag.h

Go to the documentation of this file.

#pragma once
 
#include <blam/components/content/tags/tagclass.h>
#include <blam/components/content/tags/fields.h>
 
#ifndef BLAM
#define BLAM
#endif
 
#pragma pack(push, 1)
struct test_tag
{
    int integer_test;
    short short_test;
    byte byte_test;
 
    TAG_BLOCK(bitmap_data,
    {
        short width;
        short height;
        byte depth;
        bitfield8 format_flags;
 
        TAG_ENUM(bitmap_type,
        {
            texture_2d,
            texture_3d,
            cubemap,
            unknown
        });
    });
 
    TAG_BLOCK(the_go_fuck_yourself_block,
    {
        bitfield16 extra_flags;
        bitfield32 who_needs_this_many_flags;
    });
 
    TAG_BLOCK(nested_block_test,
    {
        int nested_property;
        ascii nested_string;
 
        TAG_BLOCK(nested_block_child_block,
        {
            short please_work;
            ascii edge_1;
 
            TAG_ENUM(argh,
            {
                argh_one,
                argh_two,
                argh_three,
                argh_four
            });
 
            ascii edge_2;
 
            //tag_reference test_ref;
            data_reference test_dataref;
        });
    });
 
    //tag_reference test_ref;
    data_reference test_dataref;
 
    TAG_BLOCK(block,
    {
        int integer;
        data_reference dataref;
        TAG_BLOCK(block_two,
        {
            int integer;
            data_reference dataref;
            TAG_BLOCK(block_three,
            {
                int integer;
                data_reference dataref;
                TAG_BLOCK(block_four,
                {
                    int integer;
                    data_reference dataref;
                    TAG_BLOCK(block_five,
                    {
                        int integer;
                        data_reference dataref;
                    });
                });
            });
        });
    });
 
    int another_int;
};
#pragma pack(pop)
 
class TestTagTagClass : public BlamTagClass
{
public:
    TestTagTagClass()
    {
        class_name_long = "test_tag";
        class_name_short = "ttag";
        version = 1;
 
        revisions = {
            {1, "haloman30", "Initial implementation."},
            {2, "haloman30", "Move over test fields that were in bitmap tag for some reason"}
        };
 
        tag_size = sizeof(test_tag);
 
        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(sizeof(test_tag::bitmap_data_entry), "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(sizeof(test_tag::the_go_fuck_yourself_block_entry), "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(sizeof(test_tag::nested_block_test_entry), "nested block test", "testing block nesting",
            {
                new Int32Field("nested property", ""),
                new AsciiField("nested string", ""),
                new BlockField(sizeof(test_tag::nested_block_test_entry::nested_block_child_block_entry), "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 TagReferenceField("test ref", "testing tag reference", {"bitm", "colo"}),
                    new DataReferenceField("test dataref", "testing data reference")
                })
            }),
            //new TagReferenceField("test ref", "testing tag reference", {"bitm", "colo"}),
            new DataReferenceField("test dataref", "testing data reference"),
            new CommentField("Normal Comment", "normal, unstyled comment", BlamCommentStyle::None),
            new CommentField("Info Comment", "key information", BlamCommentStyle::Info),
            new CommentField("Warning Comment", "warning message", BlamCommentStyle::Warning),
            new CommentField("Error Comment", "error message", BlamCommentStyle::Error),
 
            new BlockField(sizeof(test_tag::block_entry), "block", "",
            {
                new Int32Field("integer", ""),
                new DataReferenceField("dataref", ""),
                new BlockField(sizeof(test_tag::block_entry), "block two", "",
                {
                    new Int32Field("integer", ""),
                    new DataReferenceField("dataref", ""),
                    new BlockField(sizeof(test_tag::block_entry), "block three", "",
                    {
                        new Int32Field("integer", ""),
                        new DataReferenceField("dataref", ""),
                        new BlockField(sizeof(test_tag::block_entry), "block four", "",
                        {
                            new Int32Field("integer", ""),
                            new DataReferenceField("dataref", ""),
                            new BlockField(sizeof(test_tag::block_entry), "block five", "",
                            {
                                new Int32Field("integer", ""),
                                new DataReferenceField("dataref", "")
                            }),
                        }),
                    }),
                }),
            }),
            new Int32Field("another int", "")
        };
    }
};
 
namespace Blam::Content::Tags
{
    
}