rdpq.h

Go to the documentation of this file.

 
#ifndef __LIBDRAGON_RDPQ_H
#define __LIBDRAGON_RDPQ_H
 
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include "graphics.h"
#include "n64sys.h"
#include "rdpq_macros.h"
#include "surface.h"
#include "debug.h"
 
 
// Static overlay ID for RDP/RDPQ commands
#define RDPQ_OVL_ID (0xC << 28)
 
// List of RDPQ internal RSP commands.
// NOTE: this is *NOT* part of the public API of rdpq.
enum {
    RDPQ_CMD_NOOP                       = 0x00,
    RDPQ_CMD_SET_LOOKUP_ADDRESS         = 0x01,
    RDPQ_CMD_FILL_RECTANGLE_EX          = 0x02,
    RDPQ_CMD_RESET_RENDER_MODE          = 0x04,
    RDPQ_CMD_SET_COMBINE_MODE_2PASS     = 0x05,
    RDPQ_CMD_PUSH_RENDER_MODE           = 0x06,
    RDPQ_CMD_POP_RENDER_MODE            = 0x07,
    RDPQ_CMD_TRI                        = 0x08,
    RDPQ_CMD_TRI_ZBUF                   = 0x09,
    RDPQ_CMD_TRI_TEX                    = 0x0A,
    RDPQ_CMD_TRI_TEX_ZBUF               = 0x0B,
    RDPQ_CMD_TRI_SHADE                  = 0x0C,
    RDPQ_CMD_TRI_SHADE_ZBUF             = 0x0D,
    RDPQ_CMD_TRI_SHADE_TEX              = 0x0E,
    RDPQ_CMD_TRI_SHADE_TEX_ZBUF         = 0x0F,
 
    RDPQ_CMD_TEXTURE_RECTANGLE_EX       = 0x10,
    RDPQ_CMD_SET_DEBUG_MODE             = 0x11,
    RDPQ_CMD_SET_SCISSOR_EX             = 0x12,
    RDPQ_CMD_SET_PRIM_COLOR_COMPONENT   = 0x13,
    RDPQ_CMD_MODIFY_OTHER_MODES         = 0x14,
    RDPQ_CMD_SET_FILL_COLOR_32          = 0x16,
    RDPQ_CMD_SET_BLENDING_MODE          = 0x18,
    RDPQ_CMD_SET_FOG_MODE               = 0x19,
    RDPQ_CMD_SET_COMBINE_MODE_1PASS     = 0x1B,
    RDPQ_CMD_AUTOTMEM_SET_ADDR          = 0x1C,
    RDPQ_CMD_AUTOTMEM_SET_TILE          = 0x1D,
    RDPQ_CMD_TRIANGLE                   = 0x1E,
    RDPQ_CMD_TRIANGLE_DATA              = 0x1F,
 
    RDPQ_CMD_TEXTURE_RECTANGLE          = 0x24,
    RDPQ_CMD_TEXTURE_RECTANGLE_FLIP     = 0x25,
    RDPQ_CMD_SYNC_LOAD                  = 0x26,
    RDPQ_CMD_SYNC_PIPE                  = 0x27,
    RDPQ_CMD_SYNC_TILE                  = 0x28,
    RDPQ_CMD_SYNC_FULL                  = 0x29,
    RDPQ_CMD_SET_KEY_GB                 = 0x2A,
    RDPQ_CMD_SET_KEY_R                  = 0x2B,
    RDPQ_CMD_SET_CONVERT                = 0x2C,
    RDPQ_CMD_SET_SCISSOR                = 0x2D,
    RDPQ_CMD_SET_PRIM_DEPTH             = 0x2E,
    RDPQ_CMD_SET_OTHER_MODES            = 0x2F,
 
    RDPQ_CMD_LOAD_TLUT                  = 0x30,
    RDPQ_CMD_DEBUG                      = 0x31,
    RDPQ_CMD_SET_TILE_SIZE              = 0x32,
    RDPQ_CMD_LOAD_BLOCK                 = 0x33,
    RDPQ_CMD_LOAD_TILE                  = 0x34,
    RDPQ_CMD_SET_TILE                   = 0x35,
    RDPQ_CMD_FILL_RECTANGLE             = 0x36,
    RDPQ_CMD_SET_FILL_COLOR             = 0x37,
    RDPQ_CMD_SET_FOG_COLOR              = 0x38,
    RDPQ_CMD_SET_BLEND_COLOR            = 0x39,
    RDPQ_CMD_SET_PRIM_COLOR             = 0x3A,
    RDPQ_CMD_SET_ENV_COLOR              = 0x3B,
    RDPQ_CMD_SET_COMBINE_MODE_RAW       = 0x3C,
    RDPQ_CMD_SET_TEXTURE_IMAGE          = 0x3D,
    RDPQ_CMD_SET_Z_IMAGE                = 0x3E,
    RDPQ_CMD_SET_COLOR_IMAGE            = 0x3F,
};
 
#define RDPQ_CFG_AUTOSYNCPIPE   (1 << 0)     
#define RDPQ_CFG_AUTOSYNCLOAD   (1 << 1)     
#define RDPQ_CFG_AUTOSYNCTILE   (1 << 2)     
#define RDPQ_CFG_AUTOSCISSOR    (1 << 3)     
#define RDPQ_CFG_DEFAULT        (0xFFFF)     
 
// Used in inline functions as part of the autosync engine. Not part of public API.
#define AUTOSYNC_TILE(n)  (1    << (0+(n)))     // Autosync state: Bit used for tile N
#define AUTOSYNC_TILES    (0xFF << 0)           // Autosync state: Mask for all bits regarding tile
#define AUTOSYNC_TMEM(n)  (1    << (8+(n)))     // Autosync state: Bit used for tmem portion N
#define AUTOSYNC_TMEMS    (0xFF << 8)           // Autosync state: Mask for all bits regarding TMEM
#define AUTOSYNC_PIPE     (1    << 16)          // Autosync state: Bit used for pipe
 
/* Used internally for bit-packing RDP commands. Not part of public API. */
#define _carg(value, mask, shift) (((uint32_t)((value) & (mask))) << (shift))
 
typedef enum {
    TILE0 = 0,  
    TILE1 = 1,  
    TILE2 = 2,  
    TILE3 = 3,  
    TILE4 = 4,  
    TILE5 = 5,  
    TILE6 = 6,  
    TILE7 = 7,  
} rdpq_tile_t;
 
 
typedef struct {
    uint8_t  palette;    
    
    // Additional mapping parameters; Leave them as 0 if not required;
    
    struct{
        bool     clamp;     
        bool     mirror;    
        uint8_t  mask;          
        int8_t   shift;         
    } s,t; // S/T directions of the tile descriptor
    
} rdpq_tileparms_t;
 
#define RDPQ_TILE_INTERNAL           TILE7
 
#ifdef __cplusplus
extern "C" {
#endif
 
extern void __rdpq_set_scissor(uint32_t, uint32_t);
 
void rdpq_init(void);
 
void rdpq_close(void);
 
 
uint32_t rdpq_config_set(uint32_t cfg);
 
uint32_t rdpq_config_enable(uint32_t cfg_enable_bits);
 
 
uint32_t rdpq_config_disable(uint32_t cfg_disable_bits);
 
inline void rdpq_set_yuv_parms(uint16_t k0, uint16_t k1, uint16_t k2, uint16_t k3, uint16_t k4, uint16_t k5)
{
    extern void __rdpq_write8_syncchange(uint32_t cmd_id, uint32_t arg0, uint32_t arg1, uint32_t autosync);
    __rdpq_write8_syncchange(RDPQ_CMD_SET_CONVERT,
        _carg(k0, 0x1FF, 13) | _carg(k1, 0x1FF, 4) | (((uint32_t)(k2 & 0x1FF)) >> 5),
        _carg(k2, 0x1F, 27) | _carg(k3, 0x1FF, 18) | _carg(k4, 0x1FF, 9) | _carg(k5, 0x1FF, 0),
        AUTOSYNC_PIPE);
}
 
#define rdpq_set_scissor(x0, y0, x1, y1) ({ \
    int32_t x0fx = (x0)*4; \
    int32_t y0fx = (y0)*4; \
    int32_t x1fx = (x1)*4; \
    int32_t y1fx = (y1)*4; \
    assertf(x0fx <= x1fx, "x1 must be greater or equal to x0"); \
    assertf(y0fx <= y1fx, "y1 must be greater or equal to y0"); \
    assertf(x0fx >= 0, "x0 must be positive"); \
    assertf(y0fx >= 0, "y0 must be positive"); \
    assertf(x1fx <= 0xFFF, "x1 must be less than 1024"); \
    assertf(y1fx <= 0xFFF, "y1 must be less than 1024"); \
    __rdpq_set_scissor( \
        _carg(x0fx, 0xFFF, 12) | _carg(y0fx, 0xFFF, 0), \
        _carg(x1fx, 0xFFF, 12) | _carg(y1fx, 0xFFF, 0)); \
})
 
 inline void rdpq_set_prim_depth_raw(uint16_t prim_z, int16_t prim_dz)
{
    // NOTE: this does not require a pipe sync
    extern void __rdpq_write8(uint32_t, uint32_t, uint32_t);
    assertf(prim_z <= 0x7FFF, "prim_z must be in [0..0x7FFF]");
    assertf((prim_dz & -prim_dz) == (prim_dz >= 0 ? prim_dz : -prim_dz),
        "prim_dz must be a power of 2");
    __rdpq_write8(RDPQ_CMD_SET_PRIM_DEPTH, 0, _carg(prim_z, 0xFFFF, 16) | _carg(prim_dz, 0xFFFF, 0));
}
 
#define rdpq_load_tile(tile, s0, t0, s1, t1) ({ \
    assertf((s0) >= 0 && (t0) >= 0 && (s1) >= 0 && (t1) >= 0, "texture coordinates must be positive"); \
    assertf((s0) < 1024 && (t0) < 1024 && (s1) < 1024 && (t1) < 1024, "texture coordinates must be smaller than 1024"); \
    rdpq_load_tile_fx((tile), (s0)*4, (t0)*4, (s1)*4, (t1)*4); \
})
 
inline void rdpq_load_tile_fx(rdpq_tile_t tile, uint16_t s0, uint16_t t0, uint16_t s1, uint16_t t1)
{
    extern void __rdpq_write8_syncchangeuse(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t);
    __rdpq_write8_syncchangeuse(RDPQ_CMD_LOAD_TILE,
        _carg(s0, 0xFFF, 12) | _carg(t0, 0xFFF, 0),
        _carg(tile, 0x7, 24) | _carg(s1-4, 0xFFF, 12) | _carg(t1-4, 0xFFF, 0),
        AUTOSYNC_TMEM(0) | AUTOSYNC_TILE(tile),
        AUTOSYNC_TILE(tile));
}
 
 
inline void rdpq_load_tlut_raw(rdpq_tile_t tile, int color_idx, int num_colors)
{
    extern void __rdpq_write8_syncchangeuse(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t);
    __rdpq_write8_syncchangeuse(RDPQ_CMD_LOAD_TLUT, 
        _carg(color_idx, 0xFF, 14), 
        _carg(tile, 0x7, 24) | _carg(color_idx+num_colors-1, 0xFF, 14),
        AUTOSYNC_TMEM(0),
        AUTOSYNC_TILE(tile));
}
 
#define rdpq_set_tile_size(tile, s0, t0, s1, t1) ({ \
    rdpq_set_tile_size_fx((tile), (s0)*4, (t0)*4, (s1)*4, (t1)*4); \
})
 
inline void rdpq_set_tile_size_fx(rdpq_tile_t tile, uint16_t s0, uint16_t t0, uint16_t s1, uint16_t t1)
{
    assertf((s0) >= 0 && (t0) >= 0 && (s1) >= 0 && (t1) >= 0, "texture coordinates must be positive");
    assertf((s0) <= 1024*4 && (t0) <= 1024*4 && (s1) <= 1024*4 && (t1) <= 1024*4, "texture coordinates must be smaller than 1024");
 
    extern void __rdpq_write8_syncchange(uint32_t, uint32_t, uint32_t, uint32_t);
    __rdpq_write8_syncchange(RDPQ_CMD_SET_TILE_SIZE,
        _carg(s0, 0xFFF, 12) | _carg(t0, 0xFFF, 0),
        _carg(tile, 0x7, 24) | _carg(s1-4, 0xFFF, 12) | _carg(t1-4, 0xFFF, 0),
        AUTOSYNC_TILE(tile));
}
 
 
inline void rdpq_load_block_fx(rdpq_tile_t tile, uint16_t s0, uint16_t t0, uint16_t num_texels, uint16_t dxt)
{
    extern void __rdpq_write8_syncchangeuse(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t);
    __rdpq_write8_syncchangeuse(RDPQ_CMD_LOAD_BLOCK,
        _carg(s0, 0xFFF, 12) | _carg(t0, 0xFFF, 0),
        _carg(tile, 0x7, 24) | _carg(num_texels-1, 0xFFF, 12) | _carg(dxt, 0xFFF, 0),
        AUTOSYNC_TMEM(0),
        AUTOSYNC_TILE(tile));
}
 
inline void rdpq_load_block(rdpq_tile_t tile, uint16_t s0, uint16_t t0, uint16_t num_texels, uint16_t tmem_pitch)
{
    assertf(num_texels <= 2048, "invalid num_texels %d: must be smaller than 2048", num_texels);
    assertf((tmem_pitch % 8) == 0, "invalid tmem_pitch %d: must be multiple of 8", tmem_pitch);
    // Dxt is the reciprocal of the number of 64 bit words in a line in 1.11 format, rounded up
    uint32_t words = tmem_pitch / 8;
    rdpq_load_block_fx(tile, s0, t0, num_texels, (2048 + words - 1) / words);
}
 
 
#define RDPQ_AUTOTMEM                 (0x8000)
#define RDPQ_AUTOTMEM_REUSE(offset)   (0x4000 | ((offset)/8))
 
 
inline void rdpq_set_tile(rdpq_tile_t tile, 
    tex_format_t format,
    int32_t tmem_addr,
    uint16_t tmem_pitch,
    const rdpq_tileparms_t *parms)
{
    static const rdpq_tileparms_t default_parms = {0};
    if (!parms) parms = &default_parms;
    else {
        assertf(parms->s.shift >= -5 && parms->s.shift <= 10, "invalid s shift %d: must be in [-5..10]", parms->s.shift);
        assertf(parms->t.shift >= -5 && parms->t.shift <= 10, "invalid t shift %d: must be in [-5..10]", parms->t.shift);
        assertf(parms->palette < 16, "invalid palette %d: must be in [0..15]", parms->palette);
    }
    bool fixup = false;
    bool reuse = false;
    uint32_t cmd_id = RDPQ_CMD_SET_TILE;
    if (tmem_addr & (RDPQ_AUTOTMEM | RDPQ_AUTOTMEM_REUSE(0))) {
        cmd_id = RDPQ_CMD_AUTOTMEM_SET_TILE;
        reuse = (tmem_addr & RDPQ_AUTOTMEM_REUSE(0)) != 0;
        fixup = true;
        tmem_addr &= ~(RDPQ_AUTOTMEM | RDPQ_AUTOTMEM_REUSE(0));
    } else {
        assertf((tmem_addr % 8) == 0, "invalid tmem_addr %ld: must be multiple of 8", tmem_addr);
        tmem_addr /= 8;
    }
    assertf((tmem_pitch % 8) == 0, "invalid tmem_pitch %d: must be multiple of 8", tmem_pitch);
    extern void __rdpq_write8_syncchange(uint32_t, uint32_t, uint32_t, uint32_t);
    extern void __rdpq_fixup_write8_syncchange(uint32_t, uint32_t, uint32_t, uint32_t);
    (fixup ? __rdpq_fixup_write8_syncchange : __rdpq_write8_syncchange)(cmd_id,
        _carg(format, 0x1F, 19) | _carg(reuse, 0x1, 18) | _carg(tmem_pitch/8, 0x1FF, 9) | _carg(tmem_addr, 0x1FF, 0),
        _carg(tile, 0x7, 24) | _carg(parms->palette, 0xF, 20) | 
        _carg(parms->t.clamp | (parms->t.mask == 0), 0x1, 19) | _carg(parms->t.mirror, 0x1, 18) | _carg(parms->t.mask, 0xF, 14) | _carg(parms->t.shift, 0xF, 10) | 
        _carg(parms->s.clamp | (parms->s.mask == 0), 0x1, 9) | _carg(parms->s.mirror, 0x1, 8) | _carg(parms->s.mask, 0xF, 4) | _carg(parms->s.shift, 0xF, 0),
        AUTOSYNC_TILE(tile));
}
 
void rdpq_set_tile_autotmem(int16_t tmem_bytes);
 
inline void rdpq_set_fill_color(color_t color) {
    extern void __rdpq_set_fill_color(uint32_t);
    __rdpq_set_fill_color((color.r << 24) | (color.g << 16) | (color.b << 8) | (color.a << 0));
}
 
inline void rdpq_set_fill_color_stripes(color_t color1, color_t color2) {
    extern void __rdpq_write8_syncchange(uint32_t cmd_id, uint32_t arg0, uint32_t arg1, uint32_t autosync);
    uint32_t c1 = (((int)color1.r >> 3) << 11) | (((int)color1.g >> 3) << 6) | (((int)color1.b >> 3) << 1) | (color1.a >> 7);
    uint32_t c2 = (((int)color2.r >> 3) << 11) | (((int)color2.g >> 3) << 6) | (((int)color2.b >> 3) << 1) | (color2.a >> 7);
    __rdpq_write8_syncchange(RDPQ_CMD_SET_FILL_COLOR, 0, (c1 << 16) | c2,
        AUTOSYNC_PIPE);
}
 
inline void rdpq_set_fog_color(color_t color)
{
    extern void __rdpq_write8_syncchange(uint32_t cmd_id, uint32_t arg0, uint32_t arg1, uint32_t autosync);
    __rdpq_write8_syncchange(RDPQ_CMD_SET_FOG_COLOR, 0, color_to_packed32(color),
        AUTOSYNC_PIPE);
}
 
inline void rdpq_set_blend_color(color_t color)
{
    extern void __rdpq_write8_syncchange(uint32_t cmd_id, uint32_t arg0, uint32_t arg1, uint32_t autosync);
    __rdpq_write8_syncchange(RDPQ_CMD_SET_BLEND_COLOR, 0, color_to_packed32(color),
        AUTOSYNC_PIPE);
}
 
inline void rdpq_set_prim_color(color_t color)
{
    // NOTE: this does not require a pipe sync
    extern void __rdpq_fixup_write8_syncchange(uint32_t, uint32_t, uint32_t, uint32_t);
    __rdpq_fixup_write8_syncchange(RDPQ_CMD_SET_PRIM_COLOR_COMPONENT, (0<<16), color_to_packed32(color), 0);
}
 
inline void rdpq_set_detail_factor(float value)
{
    // NOTE: this does not require a pipe sync
    int8_t conv = (1.0 - value) * 31;
    extern void __rdpq_fixup_write8_syncchange(uint32_t, uint32_t, uint32_t, uint32_t);
    __rdpq_fixup_write8_syncchange(RDPQ_CMD_SET_PRIM_COLOR_COMPONENT, ((conv & 0x1F) << 8) | (2<<16), 0, 0);
}
 
inline void rdpq_set_prim_lod_frac(uint8_t value)
{
    // NOTE: this does not require a pipe sync
    extern void __rdpq_fixup_write8_syncchange(uint32_t, uint32_t, uint32_t, uint32_t);
    __rdpq_fixup_write8_syncchange(RDPQ_CMD_SET_PRIM_COLOR_COMPONENT, value | (1<<16), 0, 0);
}
 
inline void rdpq_set_prim_register_raw(color_t color, uint8_t minlod, uint8_t primlod)
{
    extern void __rdpq_write8(uint32_t cmd_id, uint32_t arg0, uint32_t arg1);
    __rdpq_write8(RDPQ_CMD_SET_PRIM_COLOR, ((minlod & 0x1F) << 8) | primlod, color_to_packed32(color));
}
 
inline void rdpq_set_env_color(color_t color)
{
    extern void __rdpq_write8_syncchange(uint32_t cmd_id, uint32_t arg0, uint32_t arg1, uint32_t autosync);
    __rdpq_write8_syncchange(RDPQ_CMD_SET_ENV_COLOR, 0, color_to_packed32(color),
        AUTOSYNC_PIPE);
}
 
void rdpq_set_color_image(const surface_t *surface);
 
void rdpq_set_z_image(const surface_t* surface);
 
void rdpq_set_texture_image(const surface_t* surface);
 
inline void rdpq_set_color_image_raw(uint8_t index, uint32_t offset, tex_format_t format, uint32_t width, uint32_t height, uint32_t stride)
{
    assertf(format == FMT_RGBA32 || format == FMT_RGBA16 || 
            format == FMT_I8 || format == FMT_CI8, 
        "Image format is not supported as color image: %s\nIt must be FMT_RGBA32, FMT_RGBA16, FMT_I8 or FMT_CI8", tex_format_name(format));
    assertf(index <= 15, "Lookup address index out of range [0,15]: %d", index);
 
    extern void __rdpq_set_color_image(uint32_t, uint32_t, uint32_t, uint32_t);
    __rdpq_set_color_image(
        _carg(format, 0x1F, 19) | _carg(TEX_FORMAT_BYTES2PIX(format, stride)-1, 0x3FF, 0) | _carg(height-1, 0x1FF, 10),
        _carg(index, 0xF, 28) | (offset & 0xFFFFFF) | _carg((height-1)>>9, 0x1, 31),
        _carg(0, 0xFFF, 12) | _carg(0, 0xFFF, 0),                 // for set_scissor
        _carg(width*4, 0xFFF, 12) | _carg(height*4, 0xFFF, 0));   // for set_scissor
}
 
inline void rdpq_set_z_image_raw(uint8_t index, uint32_t offset)
{
    assertf(index <= 15, "Lookup address index out of range [0,15]: %d", index);
    extern void __rdpq_fixup_write8_syncchange(uint32_t, uint32_t, uint32_t, uint32_t);
    __rdpq_fixup_write8_syncchange(RDPQ_CMD_SET_Z_IMAGE,
        0, 
        _carg(index, 0xF, 28) | (offset & 0xFFFFFF),
        AUTOSYNC_PIPE);
}
 
inline void rdpq_set_texture_image_raw(uint8_t index, uint32_t offset, tex_format_t format, uint16_t width, uint16_t height)
{
    assertf(width <= 1024, "Texture width out of range [1,1024]: %d", width);
    assertf(height <= 1024, "Texture height out of range [1,1024]: %d", height);
    assertf(index <= 15, "Lookup address index out of range [0,15]: %d", index);
    extern void __rdpq_fixup_write8_syncchange(uint32_t, uint32_t, uint32_t, uint32_t);
    // NOTE: we also encode the texture height in the command (split in two halves...)
    // to help the validator to a better job. The RDP hardware ignores those bits.
    __rdpq_fixup_write8_syncchange(RDPQ_CMD_SET_TEXTURE_IMAGE,
        _carg(format, 0x1F, 19) | _carg(width-1, 0x3FF, 0) | _carg(height-1, 0x1FF, 10),
        _carg(index, 0xF, 28) | (offset & 0xFFFFFF) | _carg((height-1)>>9, 0x1, 31),
        AUTOSYNC_PIPE);
}
 
inline void rdpq_load_block_linear(int32_t offset, void *buffer, uint16_t size)
{
    assertf((offset & 7) == 0, "invalid TMEM offset %ld: must be 8-byte aligned", offset);
    assertf((PhysicalAddr(buffer) & 7) == 0, "invalid buffer: %p, must be 8-byte aligned", buffer);
    assertf((size & 7) == 0, "invalid size %d: must be a multiple of 8", size);
    assertf(size <= 4096, "invalid size %d: must fit TMEM", size);
    rdpq_set_texture_image_raw(0, PhysicalAddr(buffer), FMT_RGBA16, 8, size / 8);
    rdpq_set_tile(RDPQ_TILE_INTERNAL, FMT_RGBA16, offset, 0, NULL);
    uint32_t num_texels = size / 2;
    rdpq_load_block(RDPQ_TILE_INTERNAL, 0, 0, num_texels, 16);
}
 
inline void rdpq_set_lookup_address(uint8_t index, void* rdram_addr)
{
    assertf(index > 0 && index <= 15, "Lookup address index out of range [1,15]: %d", index);
    extern void __rdpq_write8(uint32_t, uint32_t, uint32_t);
    __rdpq_write8(RDPQ_CMD_SET_LOOKUP_ADDRESS, index << 2, PhysicalAddr(rdram_addr));
}
 
void rdpq_sync_pipe(void);
 
void rdpq_sync_tile(void);
 
void rdpq_sync_load(void);
 
void rdpq_sync_full(void (*callback)(void*), void* arg);
 
 
inline void rdpq_set_other_modes_raw(uint64_t mode)
{
    extern void __rdpq_set_other_modes(uint32_t, uint32_t);
    __rdpq_set_other_modes(
        (mode >> 32) & 0x00FFFFFF,
        mode & 0xFFFFFFFF);
}
 
inline void rdpq_change_other_modes_raw(uint64_t mask, uint64_t val)
{
    extern void __rdpq_change_other_modes(uint32_t, uint32_t, uint32_t);
 
    if (mask >> 32)
        __rdpq_change_other_modes(0, ~(mask >> 32), val >> 32);
    if ((uint32_t)mask)
        __rdpq_change_other_modes(4, ~(uint32_t)mask, (uint32_t)val);
}
 
uint64_t rdpq_get_other_modes_raw(void);
 
inline void rdpq_set_combiner_raw(uint64_t comb) {
    extern void __rdpq_write8_syncchange(uint32_t cmd_id, uint32_t arg0, uint32_t arg1, uint32_t autosync);
    __rdpq_write8_syncchange(RDPQ_CMD_SET_COMBINE_MODE_RAW,
        (comb >> 32) & 0x00FFFFFF,
        comb & 0xFFFFFFFF,
        AUTOSYNC_PIPE);   
}
 
void rdpq_fence(void);
 
void rdpq_exec(void *buffer, int size);
 
#define rdpq_write(num_rdp_commands, ovl_id, cmd_id, ...) ({ \
    int __num_rdp_commands = (num_rdp_commands); \
    if (!__builtin_constant_p(__num_rdp_commands) || __num_rdp_commands != 0) { \
        if (__builtin_expect(rspq_block != NULL, 0)) { \
            __rdpq_block_reserve(__num_rdp_commands); \
        } \
    } \
    rspq_write(ovl_id, cmd_id, ##__VA_ARGS__); \
})
 
// Declarations used by rdpq_write, not part of the public API.
typedef struct rspq_block_s rspq_block_t;
extern rspq_block_t *rspq_block;
extern void __rdpq_block_reserve(int); \
 
 
#ifdef __cplusplus
}
#endif
 
#endif