rdpq_mode.h

Go to the documentation of this file.

 
#ifndef LIBDRAGON_RDPQ_MODE_H
#define LIBDRAGON_RDPQ_MODE_H
 
#include "rdpq.h"
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
// Internal helpers, not part of the public API
inline void __rdpq_mode_change_som(uint64_t mask, uint64_t val);
 
void rdpq_mode_push(void);
 
void rdpq_mode_pop(void);
 
typedef enum rdpq_filter_s {
    FILTER_POINT    = SOM_SAMPLE_POINT    >> SOM_SAMPLE_SHIFT,  
    FILTER_BILINEAR = SOM_SAMPLE_BILINEAR >> SOM_SAMPLE_SHIFT,  
    FILTER_MEDIAN   = SOM_SAMPLE_MEDIAN   >> SOM_SAMPLE_SHIFT,  
} rdpq_filter_t;
 
typedef enum rdpq_dither_s {
    DITHER_SQUARE_SQUARE       = (SOM_RGBDITHER_SQUARE | SOM_ALPHADITHER_SAME)   >> SOM_ALPHADITHER_SHIFT, 
    DITHER_SQUARE_INVSQUARE    = (SOM_RGBDITHER_SQUARE | SOM_ALPHADITHER_INVERT) >> SOM_ALPHADITHER_SHIFT, 
    DITHER_SQUARE_NOISE        = (SOM_RGBDITHER_SQUARE | SOM_ALPHADITHER_NOISE)  >> SOM_ALPHADITHER_SHIFT, 
    DITHER_SQUARE_NONE         = (SOM_RGBDITHER_SQUARE | SOM_ALPHADITHER_NONE)   >> SOM_ALPHADITHER_SHIFT, 
 
    DITHER_BAYER_BAYER         = (SOM_RGBDITHER_BAYER  | SOM_ALPHADITHER_SAME)   >> SOM_ALPHADITHER_SHIFT, 
    DITHER_BAYER_INVBAYER      = (SOM_RGBDITHER_BAYER  | SOM_ALPHADITHER_INVERT) >> SOM_ALPHADITHER_SHIFT, 
    DITHER_BAYER_NOISE         = (SOM_RGBDITHER_BAYER  | SOM_ALPHADITHER_NOISE)  >> SOM_ALPHADITHER_SHIFT, 
    DITHER_BAYER_NONE          = (SOM_RGBDITHER_BAYER  | SOM_ALPHADITHER_NONE)   >> SOM_ALPHADITHER_SHIFT, 
 
    DITHER_NOISE_SQUARE        = (SOM_RGBDITHER_NOISE  | SOM_ALPHADITHER_SAME)   >> SOM_ALPHADITHER_SHIFT, 
    DITHER_NOISE_INVSQUARE     = (SOM_RGBDITHER_NOISE  | SOM_ALPHADITHER_INVERT) >> SOM_ALPHADITHER_SHIFT, 
    DITHER_NOISE_NOISE         = (SOM_RGBDITHER_NOISE  | SOM_ALPHADITHER_NOISE)  >> SOM_ALPHADITHER_SHIFT, 
    DITHER_NOISE_NONE          = (SOM_RGBDITHER_NOISE  | SOM_ALPHADITHER_NONE)   >> SOM_ALPHADITHER_SHIFT, 
 
    DITHER_NONE_BAYER          = (SOM_RGBDITHER_NONE   | SOM_ALPHADITHER_SAME)   >> SOM_ALPHADITHER_SHIFT, 
    DITHER_NONE_INVBAYER       = (SOM_RGBDITHER_NONE   | SOM_ALPHADITHER_INVERT) >> SOM_ALPHADITHER_SHIFT, 
    DITHER_NONE_NOISE          = (SOM_RGBDITHER_NONE   | SOM_ALPHADITHER_NOISE)  >> SOM_ALPHADITHER_SHIFT, 
    DITHER_NONE_NONE           = (SOM_RGBDITHER_NONE   | SOM_ALPHADITHER_NONE)   >> SOM_ALPHADITHER_SHIFT, 
} rdpq_dither_t;
 
typedef enum rdpq_tlut_s {
    TLUT_NONE   = 0,     
    TLUT_RGBA16 = 2,     
    TLUT_IA16   = 3,     
} rdpq_tlut_t;
 
inline rdpq_tlut_t rdpq_tlut_from_format(tex_format_t format) {
    switch (format) {
    case FMT_CI4:
    case FMT_CI8:
        return TLUT_RGBA16;
    default:
        return TLUT_NONE;
    }
}
 
typedef enum rdpq_mipmap_s {
    MIPMAP_NONE        = 0,                                                
    MIPMAP_NEAREST     = SOM_TEXTURE_LOD >> 32,                            
    MIPMAP_INTERPOLATE = (SOM_TEXTURE_LOD | SOMX_LOD_INTERPOLATE) >> 32,   
    MIPMAP_INTERPOLATE_SHARPEN = (SOM_TEXTURE_LOD | SOMX_LOD_INTERPOLATE | SOM_TEXTURE_SHARPEN) >> 32,   
    MIPMAP_INTERPOLATE_DETAIL = (SOM_TEXTURE_LOD | SOMX_LOD_INTERPOLATE | SOM_TEXTURE_DETAIL) >> 32,   
} rdpq_mipmap_t;
 
typedef enum rdpq_antialias_s {
    AA_NONE = 0,            
    AA_STANDARD = 1,        
    AA_REDUCED = 2,         
} rdpq_antialias_t;
 
 
void rdpq_set_mode_standard(void);
 
 
inline void rdpq_set_mode_fill(color_t color) {
    extern void __rdpq_set_mode_fill(void);
    __rdpq_set_mode_fill();
    rdpq_set_fill_color(color);
}
 
void rdpq_set_mode_copy(bool transparency);
 
void rdpq_set_mode_yuv(bool bilinear);
 
inline void rdpq_mode_antialias(rdpq_antialias_t mode) 
{
    // Just enable/disable SOM_AA_ENABLE. The RSP will then update the render mode
    // which would trigger different other bits in SOM depending on the current mode.
    __rdpq_mode_change_som(SOM_AA_ENABLE | SOMX_AA_REDUCED, 
        (mode ? SOM_AA_ENABLE : 0) | (mode == AA_REDUCED ? SOMX_AA_REDUCED : 0));
}
 
inline void rdpq_mode_combiner(rdpq_combiner_t comb) {
    extern void __rdpq_fixup_mode(uint32_t cmd_id, uint32_t w0, uint32_t w1);
    extern void __rdpq_fixup_mode4(uint32_t cmd_id, uint32_t w0, uint32_t w1, uint32_t w2, uint32_t w3);
 
    if (comb & RDPQ_COMBINER_2PASS)
        __rdpq_fixup_mode(RDPQ_CMD_SET_COMBINE_MODE_2PASS,
            (comb >> 32) & 0x00FFFFFF,
            comb & 0xFFFFFFFF);
    else {
        rdpq_combiner_t comb1_mask = RDPQ_COMB1_MASK;
        if (((comb >> 0 ) &  7) == 1) comb1_mask ^= 1ull << 0;
        if (((comb >> 3 ) &  7) == 1) comb1_mask ^= 1ull << 3;
        if (((comb >> 6 ) &  7) == 1) comb1_mask ^= 1ull << 6;
        if (((comb >> 18) &  7) == 1) comb1_mask ^= 1ull << 18;
        if (((comb >> 21) &  7) == 1) comb1_mask ^= 1ull << 21;
        if (((comb >> 24) &  7) == 1) comb1_mask ^= 1ull << 24;
        if (((comb >> 32) & 31) == 1) comb1_mask ^= 1ull << 32;
        if (((comb >> 37) & 15) == 1) comb1_mask ^= 1ull << 37;
 
        __rdpq_fixup_mode4(RDPQ_CMD_SET_COMBINE_MODE_1PASS,
            (comb >> 32) & 0x00FFFFFF,
            comb & 0xFFFFFFFF,
            (comb1_mask >> 32) & 0x00FFFFFF,
            comb1_mask & 0xFFFFFFFF);
    }
}
 
#define RDPQ_BLENDER_MULTIPLY       RDPQ_BLENDER((IN_RGB, IN_ALPHA, MEMORY_RGB, INV_MUX_ALPHA))
 
#define RDPQ_BLENDER_MULTIPLY_CONST     RDPQ_BLENDER((IN_RGB, FOG_ALPHA, MEMORY_RGB, INV_MUX_ALPHA))
 
#define RDPQ_BLENDER_ADDITIVE       RDPQ_BLENDER((IN_RGB, IN_ALPHA, MEMORY_RGB, ONE))      
 
inline void rdpq_mode_blender(rdpq_blender_t blend) {
    extern void __rdpq_fixup_mode(uint32_t cmd_id, uint32_t w0, uint32_t w1);
    if (blend) blend |= SOM_BLENDING;
    __rdpq_fixup_mode(RDPQ_CMD_SET_BLENDING_MODE, 0, blend);
}
 
inline void rdpq_mode_fog(rdpq_blender_t fog) {
    extern void __rdpq_fixup_mode(uint32_t cmd_id, uint32_t w0, uint32_t w1);
    if (fog) fog |= SOM_BLENDING;
    if (fog) assertf((fog & SOMX_BLEND_2PASS) == 0, "Fogging cannot be used with two-pass blending formulas");
    __rdpq_mode_change_som(SOMX_FOG, fog ? SOMX_FOG : 0);
    __rdpq_fixup_mode(RDPQ_CMD_SET_FOG_MODE, 0, fog);
}
 
inline void rdpq_mode_dithering(rdpq_dither_t dither) {
    __rdpq_mode_change_som(
        SOM_RGBDITHER_MASK | SOM_ALPHADITHER_MASK, ((uint64_t)dither << SOM_ALPHADITHER_SHIFT));
}
 
inline void rdpq_mode_alphacompare(int threshold) {
    if (threshold == 0) {
        __rdpq_mode_change_som(SOM_ALPHACOMPARE_MASK, 0);
    } else if (threshold > 0) {
        __rdpq_mode_change_som(SOM_ALPHACOMPARE_MASK, SOM_ALPHACOMPARE_THRESHOLD);
        rdpq_set_blend_color(RGBA32(0,0,0,(uint8_t)threshold));
    } else {
        __rdpq_mode_change_som(SOM_ALPHACOMPARE_MASK, SOM_ALPHACOMPARE_NOISE);
    }
}
 
inline void rdpq_mode_zbuf(bool compare, bool update) {
    __rdpq_mode_change_som(
        SOM_Z_COMPARE | SOM_Z_WRITE, 
        (compare ? SOM_Z_COMPARE : 0) |
        (update  ? SOM_Z_WRITE   : 0)
    );
}
 
inline void rdpq_mode_zoverride(bool enable, float z, int16_t deltaz) {
    if (enable) rdpq_set_prim_depth_raw(z * 0x7FFF, deltaz);
    __rdpq_mode_change_som(
        SOM_ZSOURCE_PRIM, enable ? SOM_ZSOURCE_PRIM : 0
    );
}
 
 
inline void rdpq_mode_tlut(rdpq_tlut_t tlut) {
    // This assert is useful to catch the common mistake of rdpq_mode_tlut(true)
    assertf(tlut == TLUT_NONE || tlut == TLUT_RGBA16 || tlut == TLUT_IA16, "invalid TLUT type");
    __rdpq_mode_change_som(SOM_TLUT_MASK, (uint64_t)tlut << SOM_TLUT_SHIFT);
}
 
inline void rdpq_mode_filter(rdpq_filter_t filt) {
    __rdpq_mode_change_som(SOM_SAMPLE_MASK, (uint64_t)filt << SOM_SAMPLE_SHIFT);
}
 
inline void rdpq_mode_mipmap(rdpq_mipmap_t mode, int num_levels) {
    if (mode == MIPMAP_NONE)
        num_levels = 0;
    if (num_levels)
        num_levels -= 1;
    __rdpq_mode_change_som(SOM_TEXTURE_LOD | SOMX_LOD_INTERPOLATE | SOMX_NUMLODS_MASK | SOM_TEXTURE_SHARPEN | SOM_TEXTURE_DETAIL, 
        ((uint64_t)mode << 32) | ((uint64_t)num_levels << SOMX_NUMLODS_SHIFT));
};
 
inline void rdpq_mode_persp(bool perspective)
{
    __rdpq_mode_change_som(SOM_TEXTURE_PERSP, perspective ? SOM_TEXTURE_PERSP : 0);
}
 
void rdpq_mode_begin(void);
 
void rdpq_mode_end(void);
 
/********************************************************************
 * Internal functions (not part of public API)
 ********************************************************************/
 
inline void __rdpq_mode_change_som(uint64_t mask, uint64_t val)
{
    // This is identical to #rdpq_change_other_modes_raw, but we also
    // set bit 1<<15 in the first word. That flag tells the RSP code
    // to recalculate the render mode, in addition to flipping the bits.
    // #rdpq_change_other_modes_raw instead just changes the bits as
    // you would expect from a raw API.
    extern void __rdpq_fixup_mode3(uint32_t cmd_id, uint32_t w0, uint32_t w1, uint32_t w2);
    if (mask >> 32)
        __rdpq_fixup_mode3(RDPQ_CMD_MODIFY_OTHER_MODES, 0 | (1<<15), ~(mask >> 32), val >> 32);
    if ((uint32_t)mask)
        __rdpq_fixup_mode3(RDPQ_CMD_MODIFY_OTHER_MODES, 4 | (1<<15), ~(uint32_t)mask, (uint32_t)val);
}
 
 
#ifdef __cplusplus
}
#endif
 
#endif