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
 
enum class bitmap_filtering_mode : uint32_t
{
    point,
    linear,
    anisotropic,
    none,
};
 
 
#pragma pack(push, 1)
struct bitmap
{
    //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.
    
    
    
    * Point - Minimal filtering mode that preserves sharp edges. Ideal for pixel art or other similar cases.
    
    * 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.
    
    * Anisotropic - Best filtering mode. Performs the poorest but gives the best possible image quality.
    
    * None - No filtering is applied. Will often be identical to Point filtering.*/
    bitmap_filtering_mode filtering_mode_min;
    bitmap_filtering_mode filtering_mode_mag;
    bitmap_filtering_mode filtering_mode_mip;
    bitfield8 flags;
    //BITMAP DATA
 
    TAG_ENUM(format,
    {
        BF_RGBA8_UNORM,
        BF_UNUSED,
    });
 
    data_reference pixel_data; 
    vector2 size; 
    int16_t bytes_per_line; 
    TAG_BLOCK(import_info,
    {
        //IMPORT INFO
        /*The fields listed below refer to data from the originally imported file, and are not used by the engine directly.*/
        int64_t source_filesize; 
        ascii source_filename; 
        ascii source_file_format; 
        ascii source_pixel_format; 
        ascii 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",
            }),
            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",
                "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(520, "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 AsciiField("source filename", "The file name (or file path) of the original image."),
                new AsciiField("source file format", "The format of the original image."),
                new AsciiField("source pixel format", "The original pixel format of the source image."),
                new AsciiField("parsed pixel format", "The pixel format of the interpreted image data during import."),
            }),
 
        };
    }
};
 
namespace Blam::Content::Tags
{
    BLAM bitmap* GetBitmapTag(std::string tag_path);
}