bitmap.h

Go to the documentation of this file.

#pragma once
 
#include "../tagclass.h"
 
#ifndef BLAM
#define BLAM
#endif
 
namespace Blam::Content::Tags
{
    enum bitmap__bitmap_type
    {
        texture_2d,
        texture_3d,
        cubemap,
        unknown
    };
 
    struct bitmap__bitmap_data
    {
        short width;
        short height;
        byte depth;
        bitfield8 format_flags;
        bitmap__bitmap_type bitmap_type;
        //bitfield8 format_flags;
    };
 
    struct the_go_fuck_yourself_block
    {
        bitfield16 extra_flags;
        bitfield32 who_needs_this_many_flags;
    };
 
    struct nested_block_child_block
    {
        short please_work;
        ascii edge_1;
        bitmap__bitmap_type bitmap_type;
        ascii edge_2;
    };
 
    struct nested_block_test_block
    {
        int nested_property;
        ascii nested_string;
        tag_block<nested_block_child_block> child_block;
    };
 
    struct format_flags_bitfield
    {
        bool bit_0;
        bool bit_1;
        bool bit_2;
        bool is_tiled;
    };
 
    struct bitmap
    {
        int integer_test;
        short short_test;
        byte byte_test;
        tag_block<bitmap__bitmap_data> bitmap_data;
        tag_block<the_go_fuck_yourself_block> the_go_fuck_yourself;
        tag_block<nested_block_test_block> nested_block_test;
    };
 
    namespace Classes
    {
        class BitmapTagClass : public BlamTagClass
        {
        public:
            BitmapTagClass()
            {
                class_name_long = "bitmap";
                class_name_short = "bitm";
                version = 1;
 
                revisions = {
                    {1, "haloman30", "Initial implementation."}
                };
 
                tag_size = sizeof(bitmap);
 
                fields =
                {
                    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 Block(sizeof(bitmap__bitmap_data), "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 EnumField("type", "the usage type of this bitmap",
                        {
                            "2d texture",
                            "3d texture",
                            "cubemap",
                            "unknown"
                        })
                    }),
                    new Block(sizeof(the_go_fuck_yourself_block), "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 Block(sizeof(nested_block_test_block), "nested block test", "testing block nesting",
                    {
                        new Int32Field("nested property", ""),
                        new AsciiField("nested string", ""),
                        new Block(sizeof(nested_block_child_block), "child block", "",
                        {
                            new Int16Field("please work", ""),
                            new AsciiField("nested string1", ""),
                            new EnumField("type", "the usage type of this bitmap",
                            {
                                "2d texture",
                                "3d texture",
                                "cubemap",
                                "unknown"
                            }),
                            new AsciiField("nested string2", "")
                        })
                    })
                };
            }
        };
    }
 
    BLAM bitmap* GetBitmapTag(std::string tag_path);
}