bitmap.h

Go to the documentation of this file.

// bitmap [bitm] - 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_bitm "bitm"
 
enum class bitmap_filtering_mode : uint32_t
{
    point,
    linear,
    anisotropic,
    none,
};
 
 
#pragma pack(push, 1)
struct bitmap
{
    bitmap_filtering_mode filtering_mode_min;
    bitmap_filtering_mode filtering_mode_mag;
    bitmap_filtering_mode filtering_mode_mip;
    struct bitfield8_flags
    {
        bool force_mip_filtering_mode : 1;
        bool force_min_filtering_mode : 1;
        bool force_mag_filtering_mode : 1;
        bool disable_auto_mipmaps : 1;
        bool disable_auto_mip_srgb_correction : 1;
        bool unused5 : 1;
        bool unused6 : 1;
        bool unused7 : 1;
    };
 
    bitfield8_flags flags; 
 
    TAG_ENUM(format,
    {
        BF_RGBA8_UNORM,
        BF_RGB8_UNORM,
        BF_UNUSED,
    });
 
    data_reference pixel_data; 
    vector2 size; 
    int16_t bytes_per_line; 
    TAG_BLOCK(import_info,
    {
        int64_t source_filesize; 
        data_reference source_filename; 
        data_reference source_file_format; 
        data_reference source_pixel_format; 
        data_reference parsed_pixel_format; 
    });
};
#pragma pack(pop)
 
class BitmapTagClass : public BlamTagClass
{
public:
    BitmapTagClass()
    {
        class_name_long = "bitmap";
        class_name_short = "bitm";
        version = 5;
 
        revisions = {
            {1, "haloman30", "Initial implementation."},
            {2, "haloman30", "Add test datarefs and tagrefs"},
            {3, "haloman30", "Remove all test fields, actual initial implementation"},
            {4, "haloman30", "Add multiple filtering enums for min, mag, mip, and allow bitmap filter mode to override material filter mode"},
            {5, "haloman30", "Add support for RGBA8_UNORM pixel formats, move format_temp to import info block as parsed_pixel_format"},
 
        };
 
        tag_size = 91;
 
        fields =
        {
            new CommentField("filtering modes",
            "The texture filtering mode adjusts how the bitmap is displayed in-game. Below is a list of all filtering modes and their ideal use cases.\n"
            "\n"
            "\n"
            "\n"
            "* Point - Minimal filtering mode that preserves sharp edges. Ideal for pixel art or other similar cases.\n"
            "\n"
            "* Linear - Balanced filtering mode that will attempt to blend pixels together to avoid a pixelated appearance, with a minimal performance impact. Ideal for most situations.\n"
            "\n"
            "* Anisotropic - Best filtering mode. Performs the poorest but gives the best possible image quality.\n"
            "\n"
            "* None - No filtering is applied. Will often be identical to Point filtering."),
            new Enum32Field("filtering mode (min)", "The texture filtering mode for minification. See comment above for details.",
            {
                "point",
                "linear",
                "anisotropic",
                "none",
            }),
            new Enum32Field("filtering mode (mag)", "The texture filtering mode for magnification. See comment above for details.",
            {
                "point",
                "linear",
                "anisotropic",
                "none",
            }),
            new Enum32Field("filtering mode (mip)", "The texture filtering mode for mip-mapping. See comment above for details.",
            {
                "point",
                "linear",
                "anisotropic",
                "none",
            }),
            new Bitfield8Field("flags", "",
            {
                "force mip filtering mode",
                "force min filtering mode",
                "force mag filtering mode",
                "disable auto mipmap generation",
                "skip srgb correction for auto mipmaps",
            }),
            new CommentField("BITMAP DATA",
            "***************************************************************************************************************************\n"
            "\n"
            "\n"
            "\n"
            "The fields below contain the raw bitmap data. It is updated when you reimport the bitmap.\n"
            "\n"
            "\n"
            "\n"
            "Any changes you make below will be lost in the next import, and may even cause 'bad things' to happen - such as invalid textures or crashes.\n"
            "\n"
            "\n"
            "\n"
            "If you wish to make any changes to a bitmap, you should simply re-import the image from its source. If the source image filehas been lost, consult the documentation for methods to export a bitmap tag back into a source image file.\n"
            "\n"
            "\n"
            "\n"
            "***************************************************************************************************************************"),
            new Enum32Field("format", "The pixel format of the bitmap data.",
            {
                "RGBA8_UNORM",
                "RGB8_UNORM",
                "UNUSED",
            }),
            new DataReferenceField("pixel data", "The raw pixel data for the bitmap."),
            new Vector2Field("size", "The resolution of the bitmap."),
            new Int16Field("bytes per line", "The amount of bytes needed for a single line/row of pixels for this bitmap."),
            new BlockField(136, "import info", "",
            {
                new CommentField("IMPORT INFO",
                "The fields listed below refer to data from the originally imported file, and are not used by the engine directly."),
                new Int64Field("source filesize", "The file size of the original image, in bytes."),
                new DataReferenceField("source filename", "The file name (or file path) of the original image."),
                new DataReferenceField("source file format", "The format of the original image."),
                new DataReferenceField("source pixel format", "The original pixel format of the source image."),
                new DataReferenceField("parsed pixel format", "The pixel format of the interpreted image data during import."),
            }),
 
        };
    }
};
 
namespace Blam::Content::Tags
{
    BLAM bitmap* GetBitmapTag(std::string tag_path);
}