shbin.h

Go to the documentation of this file.

/**
 * @file shbin.h
 * @brief Shader binary support.
 */
#pragma once
 
#include <3ds/gpu/gpu.h>
 
/// DVLE type.
typedef enum{
    VERTEX_SHDR=GPU_VERTEX_SHADER,    ///< Vertex shader.
    GEOMETRY_SHDR=GPU_GEOMETRY_SHADER ///< Geometry shader.
}DVLE_type;
 
/// Constant type.
typedef enum{
    DVLE_CONST_BOOL=0x0,    ///< Bool.
    DVLE_CONST_u8=0x1,      ///< Unsigned 8-bit integer.
    DVLE_CONST_FLOAT24=0x2, ///< 24-bit float.
}DVLE_constantType;
 
/// Output attribute.
typedef enum{
    RESULT_POSITION = 0x0,   ///< Position.
    RESULT_NORMALQUAT = 0x1, ///< Normal Quaternion.
    RESULT_COLOR = 0x2,      ///< Color.
    RESULT_TEXCOORD0 = 0x3,  ///< Texture coordinate 0.
    RESULT_TEXCOORD0W = 0x4, ///< Texture coordinate 0 W.
    RESULT_TEXCOORD1 = 0x5,  ///< Texture coordinate 1.
    RESULT_TEXCOORD2 = 0x6,  ///< Texture coordinate 2.
    RESULT_VIEW = 0x8,       ///< View.
    RESULT_DUMMY = 0x9,      ///< Dummy attribute (used as passthrough for geometry shader input).
}DVLE_outputAttribute_t;
 
/// Geometry shader operation modes.
typedef enum
{
    GSH_POINT         = 0, ///< Point processing mode.
    GSH_VARIABLE_PRIM = 1, ///< Variable-size primitive processing mode.
    GSH_FIXED_PRIM    = 2, ///< Fixed-size primitive processing mode.
} DVLE_geoShaderMode;
 
/// DVLP data.
typedef struct{
    u32 codeSize;     ///< Code size.
    u32* codeData;    ///< Code data.
    u32 opdescSize;   ///< Operand description size.
    u32* opcdescData; ///< Operand description data.
}DVLP_s;
 
/// DVLE constant entry data.
typedef struct{
    u16 type;    ///< Constant type. See @ref DVLE_constantType
    u16 id;      ///< Constant ID.
    u32 data[4]; ///< Constant data.
}DVLE_constEntry_s;
 
/// DVLE output entry data.
typedef struct{
    u16 type;  ///< Output type. See @ref DVLE_outputAttribute_t
    u16 regID; ///< Output register ID.
    u8 mask;   ///< Output mask.
    u8 unk[3]; ///< Unknown.
}DVLE_outEntry_s;
 
/// DVLE uniform entry data.
typedef struct{
    u32 symbolOffset; ///< Symbol offset.
    u16 startReg;     ///< Start register.
    u16 endReg;       ///< End register.
}DVLE_uniformEntry_s;
 
/// DVLE data.
typedef struct{
    DVLE_type type;                        ///< DVLE type.
    bool mergeOutmaps;                     ///< true = merge vertex/geometry shader outmaps ('dummy' output attribute is present).
    DVLE_geoShaderMode gshMode;            ///< Geometry shader operation mode.
    u8 gshFixedVtxStart;                   ///< Starting float uniform register number for storing the fixed-size primitive vertex array.
    u8 gshVariableVtxNum;                  ///< Number of fully-defined vertices in the variable-size primitive vertex array.
    u8 gshFixedVtxNum;                     ///< Number of vertices in the fixed-size primitive vertex array.
    DVLP_s* dvlp;                          ///< Contained DVLPs.
    u32 mainOffset;                        ///< Offset of the start of the main function.
    u32 endmainOffset;                     ///< Offset of the end of the main function.
    u32 constTableSize;                    ///< Constant table size.
    DVLE_constEntry_s* constTableData;     ///< Constant table data.
    u32 outTableSize;                      ///< Output table size.
    DVLE_outEntry_s* outTableData;         ///< Output table data.
    u32 uniformTableSize;                  ///< Uniform table size.
    DVLE_uniformEntry_s* uniformTableData; ///< Uniform table data.
    char* symbolTableData;                 ///< Symbol table data.
    u8 outmapMask;                         ///< Output map mask.
    u32 outmapData[8];                     ///< Output map data.
    u32 outmapMode;                        ///< Output map mode.
    u32 outmapClock;                       ///< Output map attribute clock.
}DVLE_s;
 
/// DVLB data.
typedef struct{
    u32 numDVLE;  ///< DVLE count.
    DVLP_s DVLP;  ///< Primary DVLP.
    DVLE_s* DVLE; ///< Contained DVLE.
}DVLB_s;
 
/**
 * @brief Parses a shader binary.
 * @param shbinData Shader binary data.
 * @param shbinSize Shader binary size.
 * @return The parsed shader binary.
 */
DVLB_s* DVLB_ParseFile(u32* shbinData, u32 shbinSize);
 
/**
 * @brief Frees shader binary data.
 * @param dvlb DVLB to free.
 */
void DVLB_Free(DVLB_s* dvlb);
 
/**
 * @brief Gets a uniform register index from a shader.
 * @param dvle Shader to get the register from.
 * @param name Name of the register.
 * @return The uniform register index.
 */
s8 DVLE_GetUniformRegister(DVLE_s* dvle, const char* name);
 
/**
 * @brief Generates a shader output map.
 * @param dvle Shader to generate an output map for.
 */
void DVLE_GenerateOutmap(DVLE_s* dvle);