F3DZEX2/Opcode Details
This is a sub-page of F3DZEX2.
This is a detailed explanation of all the opcodes known in F3DZEX2. Parameters are explained in terms of various macros N64 programmers had access to, since those parameters will in quite a few cases be easier to describe than their raw GBI form.
Contents
- 1 0x00 — G_NOOP
- 2 0x01 — G_VTX
- 3 0x02 — G_MODIFYVTX
- 4 0x03 — G_CULLDL
- 5 0x04 — G_BRANCH_Z
- 6 0x05 — G_TRI1
- 7 0x06 — G_TRI2
- 8 0x07 — G_QUAD
- 9 0xD3 — G_SPECIAL_3
- 10 0xD4 — G_SPECIAL_2
- 11 0xD5 — G_SPECIAL_1
- 12 0xD6 — G_DMA_IO
- 13 0xD7 — G_TEXTURE
- 14 0xD8 — G_POPMTX
- 15 0xD9 — G_GEOMETRYMODE
- 16 0xDA — G_MTX
- 17 0xDB — G_MOVEWORD
- 18 0xDC — G_MOVEMEM
- 19 0xDD — G_LOAD_UCODE
- 20 0xDE — G_DL
- 21 0xDF — G_ENDDL
- 22 0xE0 — G_SPNOOP
- 23 0xE1 — G_RDPHALF_1
- 24 0xE2 — G_SETOTHERMODE_L
- 25 0xE3 — G_SETOTHERMODE_H
- 26 0xE4 — G_TEXRECT
- 27 0xE5 — G_TEXRECTFLIP
- 28 0xE6 — G_RDPLOADSYNC
- 29 0xE7 — G_RDPPIPESYNC
- 30 0xE8 — G_RDPTILESYNC
- 31 0xE9 — G_RDPFULLSYNC
- 32 0xEA — G_SETKEYGB
- 33 0xEB — G_SETKEYR
- 34 0xEC — G_SETCONVERT
- 35 0xED — G_SETSCISSOR
- 36 0xEE — G_SETPRIMDEPTH
- 37 0xEF — G_RDPSETOTHERMODE
- 38 0xF0 — G_LOADTLUT
- 39 0xF1 — G_RDPHALF_2
- 40 0xF2 — G_SETTILESIZE
- 41 0xF3 — G_LOADBLOCK
- 42 0xF4 — G_LOADTILE
- 43 0xF5 — G_SETTILE
- 44 0xF6 — G_FILLRECT
- 45 0xF7 — G_SETFILLCOLOR
- 46 0xF8 — G_SETFOGCOLOR
- 47 0xF9 — G_SETBLENDCOLOR
- 48 0xFA — G_SETPRIMCOLOR
- 49 0xFB — G_SETENVCOLOR
- 50 0xFC — G_SETCOMBINE
- 51 0xFD — G_SETTIMG
- 52 0xFE — G_SETZIMG
- 53 0xFF — G_SETCIMG
0x00 — G_NOOP
Argument Mapping
Microcode | Reference Function |
---|---|
00000000 tttttttt | gsDPNoOp() gsDPNoOpTag(tag) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
tag | tag | tttttttt | Pointer to a string tag |
Description
Does nothing except stall the RDP for a few cycles. Typically used in debugging. In the Z64 games (specifically the debug builds), tag is set to a pointer to a string commenting the display list, which would then likely be output when calling the SDK's guParseGbiDL function.
0x01 — G_VTX
Argument Mapping
Microcode | Reference Function |
---|---|
010nn0aa vvvvvvvv | gsSPVertex(vaddr, numv, vbidx) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
numv | numv | nn | Number of vertices to load |
vbidx | ((vbidx + numv) & 0x7F) << 1 | aa >> 1 - nn | Index of vertex buffer to begin storing vertices to. |
vaddr | vaddr | vvvvvvvv | Address of vertices |
Description
Loads numv vertices from address vaddr to the RSP's vertex buffer, starting at buffer index vbidx. For F3DEX2.NoN, numv must be in the range 1 ≤ numv ≤ 32, and vbidx in the range 0 ≤ vbidx ≤ 31. Vertex transformations and lighting calculations (if any) are calculated upon load.
0x02 — G_MODIFYVTX
Argument Mapping
Microcode | Reference Function |
---|---|
02wwnnnn vvvvvvvv | gsSPModifyVertex(vbidx, where, val) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
where | where | ww | Enumerated set of values specifying what to change |
vbidx | vbidx * 2 | nnnn / 2 | Vertex buffer index of vertex to modify |
val | val | vvvvvvvv | New value to insert |
Description
Modifies a four-byte portion of the vertex specified by vbidx. The portion modified is specified by where, and the new value is given in val. Lighting calculations (if enabled) and position transformations are not calculated by the RSP after use of this command, so modifications modify final color and vertices.
The valid values for where have names as follows:
- G_MWO_POINT_RGBA = 0x10 Modifies the color of the vertex
- G_MWO_POINT_ST = 0x14 Modifies the texture coordinates
- G_MWO_POINT_XYSCREEN = 0x18 Modifies the X and Y position
- G_MWO_POINT_ZSCREEN = 0x1C Modifies the Z position (lower four nybbles of val should always be zero for this modification)
The exact nature of these values is unclear. The SDK documentation describes them as "byte offsets", however they don't match offsets in the vertex structure (see below).
0x03 — G_CULLDL
Argument Mapping
Microcode | Reference Function |
---|---|
0300vvvv 0000wwww | gsSPCullDisplayList(vfirst, vlast) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
vfirst | vfirst * 2 | vvvv / 2 | Vertex buffer index of first vertex for bounding volume |
vlast | vlast * 2 | wwww / 2 | Vertex buffer index of last vertex for bounding volume |
Description
This command takes the vertices in the vertex buffer from vfirst through vlast as describing the volume of the object being rendered (called the "bounding value"). If the bounding volume does not intersect with the current viewing volume (aka if the bounding volume is entirely offscreen), then the display list ends, equivalent to a DF opcode. Otherwise, the display list continues as though nothing happened (equivalent to 00, then).
For F3DEX2.NoN, Each of vfirst and vlast must be in the range 0 ≤ x ≤ 31. Additionally, vfirst < vlast must be true (thus a minimum of two vertices must be specified, and range of vertices cannot be reversed). It's not specified what the behavior is when all the vertices are coplanar.
0x04 — G_BRANCH_Z
Argument Mapping
Microcode | Reference Function |
---|---|
E1000000 dddddddd 04aaabbb zzzzzzzz |
gsSPBranchLessZraw(newdl, vbidx, zval) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
newdl | newdl | dddddddd | Address of display list to branch to |
vbidx | vbidx * 5 | aaa / 5 | Vertex buffer index of vertex to test |
vbidx | vbidx * 2 | bbb / 2 | Vertex buffer index of vertex to test |
zval | zval | zzzzzzzz | Z value to test against |
Description
Tests the Z value of the vertex at buffer index vbidx (described as vbidx.z here) against zval. If vbidx.z ≤ zval, then the processor switches over to the display list at address newdl (equivalent to gsSPBranchList(newdl)). Otherwise continues through the display list. Useful for LOD-related model processing, where several occurrences of this can be stacked to branch to progressively closer versions of the model.
Note that the 04 opcode actually pulls the address of the branching display list from the high half of the "RDP word" (16 bytes used for generic value storage, as far as is known). The italicized opcode given above is set by the "basic function" listed for this opcode, immediately before the actual 04 opcode.
Although not stated in the documentation, vbidx is presumably limited to the range 0 ≤ vbidx ≤ 31 just like other buffer indices. It's unknown why the opcode needs vbidx twice, and multiplied by different amounts.
Also, zval is usually calculated for the N64 programmer (only the *Zraw form specifies a raw zval). The formula used in these cases is as shown, written as C code:
#include <stdint.h>
int32_t FTOFIX32(float x) {
return (int32_t)(x * 0x00010000);
}
// note: parameter types taken from docs on gSPBranchLessZrg(...)
uint32_t calcZVal(float zval, int32_t flag, float near, float far, int32_t zmin, int32_t zmax) {
float part1 = (flag == G_BZ_PERSP)
? (1.0f - near / zval) / (1.0f - near / far)
: (zval - near) / (far - near);
return (uint32_t)FTOFIX32(part1) * ((zmax - zmin) & ~1) + FTOFIX32((float)zmin);
}
Where zval is the Z value the programmer is thinking of comparing against (whereas the "real" Z value handed to the opcode is calculated by this function), near and far denote the distances of the near and far clipping planes, respectively, from the viewpoint. zmin and zmax are the minimum and maximum posible Z values, respectively. flag decides on the projection, taking either of these enumerations:
- G_BZ_PERSP = 0
- G_BZ_ORTHO = 1
As their names would suggest, PERSP handles perspective projection, ORTHO handles orthographic.
Note that in a default setup, zmin is 0, and zmax is 0x03FF.
This formula cannot be reversed for the value provided in the microcode, since the necessary information is absent. (Since the values are provided in the macro call generating this opcode, there's no guarantee any of the values match what they're "supposed" to be, e.g. near could be set to something far different from the location of the actual near clipping plane.)
0x05 — G_TRI1
Argument Mapping
Microcode | Reference Function |
---|---|
05aabbcc 00000000 | gsSP1Triangle(v0, v1, v2, flag) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
(v0|v1|v2) | (v0|v1|v2) * 2 | (aa|bb|cc) / 2 | Vertex buffer index of one vertex of the triangle |
Description
Draws one triangle to screen. v0, v1, and v2 specify vertex buffer indices, all in the range 0 ≤ v ≤ 31 for F3DEX2.NoN.
Vertices are drawn in the order aa -> bb -> cc. aa is considered the "primary" vertex of the triangle, which matters in certain situations (for example, its color is taken as the color of the whole triangle when doing flat shading).
The given macro (gsSP1Triangle) reorders its arguments depending on the value of flag (which is why the argument listing above is generalized). It can be seen as choosing the primary vertex:
- flag == 0
- aa = v0, bb = v1, cc = v2
- flag == 1
- aa = v1, bb = v2, cc = v0
- flag == 2
- aa = v2, bb = v0, cc = v1
0x06 — G_TRI2
Argument Mapping
Microcode | Reference Function |
---|---|
06aabbcc 00ddeeff | gsSP2Triangles(v00, v01, v02, flag0, v10, v11, v12, flag1) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
(v00|v01|v02) | (v00|v01|v02) * 2 | (aa|bb|cc) / 2 | Vertex buffer index of one vertex of the first triangle |
(v10|v11|v12) | (v10|v11|v12) * 2 | (dd|ee|ff) / 2 | Vertex buffer index of one vertex of the first triangle |
Description
Draws two triangles at once. All six given indices must be in the range 0 ≤ v ≤ 31 for F3DEX2.NoN.
The first triangle is drawn in the order aa -> bb -> cc, with aa being the "primary" vertex. The second triangle is similar, drawn in dd -> ee -> ff order and dd being its "primary" vertex.
flag0 reorders the vertices for the first triangle, and flag1 reorders them for the second triangle. Either flag works as such:
- flagX == 0
- aa = vX0, bb = vX1, cc = vX2
- flagX == 1
- aa = vX1, bb = vX2, cc = vX0
- flagX == 2
- aa = vX2, bb = vX0, cc = vX1
0x07 — G_QUAD
Argument Mapping
Microcode | Reference Function |
---|---|
07aabbcc 00aaccdd | gsSPQuadrangle(v0, v1, v2, v3, flag) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
(v0|v1|v2|v3) | (v0|v1|v2|v3) * 2 | (aa|bb|cc|dd) / 2 | Vertex buffer index of one vertex of the quadrangle |
Description
Draws a quadrangle, as two triangles. All four vertex indices are in the range 0 ≤ v ≤ 31 for F3DEX2.NoN.
The macro given takes the four vertices and rearranges them according to flag, and as per the opcode writes it as two triangles. The draw order is aa -> bb -> cc for the first triangle, aa -> cc -> dd, with aa being the "primary" vertex for both (thus maintaining a single "primary" vertex for the quadrangle). Both occurrences of aa should be equal, as well as both of cc, since the purpose of this opcode is to draw a quadrilateral polygon.
The flag determines the vertices as such:
- flag == 0
- aa = v0, bb = v1, cc = v2, dd = v3
- flag == 1
- aa = v1, bb = v2, cc = v3, dd = v0
- flag == 2
- aa = v2, bb = v3, cc = v0, dd = v1
- flag == 3
- aa = v3, bb = v0, cc = v1, dd = v2
Note: This opcode is functionally equivalent to opcode 06. The macro for this opcode (and thus presumably also the opcode itself) is labeled as no longer supported in Oct 1999 SDK documentation. If you're making new display lists to import into OoT, use 06 instead of this.
0xD3 — G_SPECIAL_3
Argument Mapping
Microcode | Reference Function |
---|---|
D3?????? ???????? | G_SPECIAL_3 (no function known) |
No arguments for this opcode
Description
Appears to be an explicitly reserved command.
0xD4 — G_SPECIAL_2
Argument Mapping
Microcode | Reference Function |
---|---|
D4?????? ???????? | G_SPECIAL_2 (no function known) |
No arguments for this opcode
Description
Appears to be an explicitly reserved command.
0xD5 — G_SPECIAL_1
Argument Mapping
Microcode | Reference Function |
---|---|
D5?????? ???????? | G_SPECIAL_1 (no function known) |
No arguments for this opcode
Description
Appears to be an explicitly reserved command.
0xD6 — G_DMA_IO
Argument Mapping
Microcode | Reference Function |
---|---|
D6___sss rrrrrrrr ___ -> fmmm mmmm mmm0 (binary) |
gsSPDma_io(flag, dmem, dram, size) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
flag | flag & 0x01 | f | Chooses between read or write |
dmem | dmem / 8 & 0x3FF | mmm mmmm mmm * 8 | Address in DMEM/IMEM(?) |
size | size - 1 | sss + 1 | (Presumably) size of data to transfer |
dram | dram | rrrrrrrr | DRAM address |
Description
Does a DMA between DMEM/IMEM address dmem and DRAM address dram. size bytes are presumably transfered in the process. flag determines the type of transfer. Apparently:
- flag == 0 — Read from DMEM/IMEM to DRAM
- flag == 1 — Write DRAM to DMEM/IMEM
The exact nature of this command is unclear, since none of this opcode's macros are documented, and the only available comment suggests this is a debugging tool only. Therefore, you should not expect to see this in production code.
0xD7 — G_TEXTURE
Argument Mapping
Microcode | Reference Function |
---|---|
D700____ sssstttt ____ -> 00LL Lddd nnnn nnn0 (binary) |
gsSPTexture(scaleS, scaleT, level, tile, on) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
level | level & 0x07 | LL L | Maximum number of mipmap levels aside from the first |
tile | tile & 0x07 | ddd | Tile descriptor number |
on | on & 0x7F | n | Decides whether to turn the given texture on or off |
scaleS | scaleS | ssss | Scaling factor for the S-axis (horizontal) |
scaleT | scaleT | tttt | Scaling factor for the T-axis (vertical) |
Description
This opcode enables or disables various tile descriptors, and sets the maximum number of mipmap levels and scaling factor for the texture.
tile is the tile descriptor number being modified by the opcode. level is the maximum number of mipmap levels minus one, (so e.g. a level of zero means at most one mipmap). The scaleS and scaleT parameters set scaling factors for the tile descriptor.
If on is set to 0, then the tile descriptor is disabled, and none of the other parameters are actually applied. If on is set to 1, then the tile descriptor is enabled and the previously-mentioned parameters are applied.
Note that scaleS and scaleT are binary fractional values with an implied 0.; for example, a scaleS of 0x8000 means 0b0.1000_0000_0000_0000, or 0d0.5.
0xD8 — G_POPMTX
Argument Mapping
Microcode | Reference Function |
---|---|
D8380002 aaaaaaaa | gsSPPopMatrixN(which, num) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
num | num * 64 | aaaaaaaa / 64 | The number of matrices to pop |
which | Ignored | Ignored | Specifies which matrix stack to pop from |
Description
Pops num matrices from the stack specified by which
which can be either of:
- G_MTX_MODELVIEW = 0x00
- G_MTX_PROJECTION = 0x04
However, since the projection matrix "stack" isn't actually a stack, the which parameter is silently ignored and always assumes the modelview matrix stack.
0xD9 — G_GEOMETRYMODE
Argument Mapping
Microcode | Reference Function |
---|---|
D9cccccc ssssssss | gsSPGeometryMode(clearbits, setbits) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
clearbits | ~clearbits | ~cccccc | Geometry mode bits to clear |
setbits | setbits | ssssssss | Geometry mode bits to set |
Description
Changes the various mode bits of the RSP's geometry mode. This opcode can clear and set bits at once.
Assuming G to stand for the geometry mode bits, this command performs the equivalent of
G = (G & ~clearbits) | setbits
That is, keeps only the bits that aren't meant to be cleared, and then sets the bits that are meant to be set. See below for a list of what the geometry mode bits mean.
0xDA — G_MTX
Argument Mapping
Microcode | Reference Function |
---|---|
DA3800pp mmmmmmmm | gsSPMatrix(mtxaddr, params) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
params | params ^ G_MTX_PUSH | pp ^ G_MTX_PUSH | Parameters controlling nature of matrix addition |
mtxaddr | mtxaddr | mmmmmmmm | RAM address of new matrix |
Description
Adds a new matrix from mtxaddr to the appropriate matrix stack.
params are a bitfield with the following options:
- G_MTX_NOPUSH = 0x00
- G_MTX_PUSH = 0x01
- G_MTX_MUL = 0x00
- G_MTX_LOAD = 0x02
- G_MTX_MODELVIEW = 0x00
- G_MTX_PROJECTION = 0x04
NOPUSH and PUSH, MUL and LOAD, and MODELVIEW and PROJECTION are exclusive pairs of options. NOPUSH, MUL, and MODELVIEW are "default options", and are named just as programmer convenience, to explicitly state choices.
If PUSH is specified, then the matrix will be added to the top of the stack as a new stack element. If there is no room on the stack, this option is ignored and NOPUSH behavior occurs instead. NOPUSH means the top matrix of the stack will be overwritten with the new matrix.
If MUL is specified, the new matrix is multiplied by the top of the stack before being placed according to PUSH/NOPUSH. Specifically the matrix product of new matrix * top of the stack (XXX verify this is the right order, since matrix multiplication ain't commutative). LOAD means no multiplication is done against the new matrix.
MODELVIEW selects the modelview matrix stack (meaning the new matrix is a modelview matrix), while PROJECTION refers to the projection matrix "stack". Since the projection matrix "stack" is not actually a stack, rather a single matrix, the PUSH option is always ignored for new projection matrices.
0xDB — G_MOVEWORD
Argument Mapping
Microcode | Reference Function |
---|---|
DBiioooo dddddddd | gsMoveWd(index, offset, data)
gsSPSegment(segment, base) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
index | index | ii | Index into DMEM pointer table(?) |
offset | offset | oooo | Offset from the indexed base address(?) |
data | data | dddddddd | New 32-bit value |
Description
Loads a new 32-bit value data to the location specified by index and offset.
index is an index into a table of DMEM addresses. The enumerations given for this for F3DEX2 are:
Define | Value |
---|---|
G_MW_MATRIX | 0x00 |
G_MW_NUMLIGHT | 0x02 |
G_MW_CLIP | 0x04 |
G_MW_SEGMENT | 0x06 |
G_MW_FOG | 0x08 |
G_MW_LIGHTCOL | 0x0A |
G_MW_FORCEMTX | 0x0C |
G_MW_PERSPNORM | 0x0E |
The offset is, as the name suggests, an offset from the address that index resolves to. G_MWO_SEGMENT_# does not follow this rule, and is expected to be used with the gsSPSegment macro. Enumerations are also provided for this value, for each of the enumerated index values.
Values
Define | Value |
---|---|
G_MWO_NUMLIGHT | 0x00 |
G_MWO_CLIP_RNX | 0x04 |
G_MWO_CLIP_RNY | 0x0c |
G_MWO_CLIP_RPX | 0x14 |
G_MWO_CLIP_RPY | 0x1c |
G_MWO_SEGMENT_0 | 0x00 |
G_MWO_SEGMENT_1 | 0x01 |
G_MWO_SEGMENT_2 | 0x02 |
G_MWO_SEGMENT_3 | 0x03 |
G_MWO_SEGMENT_4 | 0x04 |
G_MWO_SEGMENT_5 | 0x05 |
G_MWO_SEGMENT_6 | 0x06 |
G_MWO_SEGMENT_7 | 0x07 |
G_MWO_SEGMENT_8 | 0x08 |
G_MWO_SEGMENT_9 | 0x09 |
G_MWO_SEGMENT_A | 0x0a |
G_MWO_SEGMENT_B | 0x0b |
G_MWO_SEGMENT_C | 0x0c |
G_MWO_SEGMENT_D | 0x0d |
G_MWO_SEGMENT_E | 0x0e |
G_MWO_SEGMENT_F | 0x0f |
G_MWO_FOG | 0x00 |
G_MWO_aLIGHT_1 | 0x00 |
G_MWO_bLIGHT_1 | 0x04 |
G_MWO_aLIGHT_2 | 0x18 |
G_MWO_bLIGHT_2 | 0x1c |
G_MWO_aLIGHT_3 | 0x30 |
G_MWO_bLIGHT_3 | 0x34 |
G_MWO_aLIGHT_4 | 0x48 |
G_MWO_bLIGHT_4 | 0x4c |
G_MWO_aLIGHT_5 | 0x60 |
G_MWO_bLIGHT_5 | 0x64 |
G_MWO_aLIGHT_6 | 0x78 |
G_MWO_bLIGHT_6 | 0x7c |
G_MWO_aLIGHT_7 | 0x90 |
G_MWO_bLIGHT_7 | 0x94 |
G_MWO_aLIGHT_8 | 0xa8 |
G_MWO_bLIGHT_8 | 0xac |
G_MWO_MATRIX_XX_XY_I | 0x00 |
G_MWO_MATRIX_XZ_XW_I | 0x04 |
G_MWO_MATRIX_YX_YY_I | 0x08 |
G_MWO_MATRIX_YZ_YW_I | 0x0c |
G_MWO_MATRIX_ZX_ZY_I | 0x10 |
G_MWO_MATRIX_ZZ_ZW_I | 0x14 |
G_MWO_MATRIX_WX_WY_I | 0x18 |
G_MWO_MATRIX_WZ_WW_I | 0x1c |
G_MWO_MATRIX_XX_XY_F | 0x20 |
G_MWO_MATRIX_XZ_XW_F | 0x24 |
G_MWO_MATRIX_YX_YY_F | 0x28 |
G_MWO_MATRIX_YZ_YW_F | 0x2c |
G_MWO_MATRIX_ZX_ZY_F | 0x30 |
G_MWO_MATRIX_ZZ_ZW_F | 0x34 |
G_MWO_MATRIX_WX_WY_F | 0x38 |
G_MWO_MATRIX_WZ_WW_F | 0x3c |
G_MWO_POINT_RGBA | 0x10 |
G_MWO_POINT_ST | 0x14 |
G_MWO_POINT_XYSCREEN | 0x18 |
G_MWO_POINT_ZSCREEN | 0x1c |
0xDC — G_MOVEMEM
Argument Mapping
Microcode | Reference Function |
---|---|
DCnnooii aaaaaaaa | gsMoveMem(size, index, offset, address) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
size | ((size - 1) / 8 & 0x1F) << 3 | ((nn >> 3) + 1) * 8 | Size in bytes of memory to be moved |
offset | offset / 8 | oo * 8 | Offset from indexed base address |
index | index | ii | Index into table of DMEM addresses |
address | address | aaaaaaaa | RAM address of memory |
Description
Transfers a block of data from RDRAM to DMEM, in 8 byte chunks. Size is the number of bytes to copy from RDRAM address, placing it at the DMEM location pointed to by index, plus offset.
index is an index into a table of addresses of DMEM. Given enumerations for index are:
- G_MV_MMTX = 2
- G_MV_PMTX = 6
- G_MV_VIEWPORT = 8
- G_MV_LIGHT = 10
- G_MV_POINT = 12
- G_MV_MATRIX = 14
Note however that only VIEWPORT, LIGHT, and MATRIX are used by any of the macros given to programmers.
offset is, as the name would suggest, an offset from the address index resolves to. This could be anything, though a couple enumerations are provided. (XXX list them here or elsewhere?)
Also note that the function gsMoveMem is imaginary: all of the macros that use this opcode do so directly, as opposed to going through another function. Since no general macro exists for this opcode, gsMoveMem was invented for illustrative purposes.
0xDD — G_LOAD_UCODE
Argument Mapping
Microcode | Reference Function |
---|---|
E1000000 dddddddd DD00ssss tttttttt |
gsSPLoadUcodeEx(tstart, dstart, dsize) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
dstart | dstart | dddddddd | Start of data section |
dsize | dsize | ssss | Size of data section |
tstart | tstart | tttttttt | Start of text section |
Description
Loads a new microcode executable into the RSP, with pointers dstart to the start of the data section and tstart to the start of the text section, with dsize specifying the size of the data section. After loading the new microcode, the RCP is reset as appropriate.
Note that dstart is stored in the high half of the "RDP word", the opcode for which is shown in italics before the actual DD opcode.
0xDE — G_DL
Argument Mapping
Microcode | Reference Function |
---|---|
DEpp0000 dddddddd | gsSPDisplayList(dl) gsSPBranchList(dl) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
pp determined by choice of function; see below | |||
dl | dl | dddddddd | Address of new display list to jump to |
Description
Tells the RDP to switch over to the display list at address dl. pp mentions what will happen when the end of the new display list is reached.
If pp is set to zero (using gsSPDisplayList), then the current address the display list processor is at is pushed to a display list address stack before switching over. This means execution returns at this point after the new display list is done.
If pp is set to one (using gsSPBranchList), then the current address isn't saved, meaning execution can't return to this point after the new display list is done. (It will instead return to the existing top of the address stack, if any addresses are there.)
0xDF — G_ENDDL
Argument Mapping
Microcode | Reference Function |
---|---|
DF000000 00000000 | gsSPEndDisplayList() |
No arguments for this opcode
Description
Ends the current display list. At this point execution will return to the address of the top of the display list address stack. If there are no addresses in this stack, that's the end of graphics processing, until the RCP is asked to do more.
0xE0 — G_SPNOOP
Argument Mapping
Microcode | Reference Function |
---|---|
E0000000 00000000 | gsSPNoOp() |
No arguments for this opcode
Description
Does nothing. Seemingly different from 00; judging by the names of this opcode and 00, this opcode stalls the RSP, whereas the other stalls the RDP.
0xE1 — G_RDPHALF_1
Argument Mapping
Microcode | Reference Function |
---|---|
E1000000 hhhhhhhh | gsDPWord(wordhi, wordlo) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
wordhi | wordhi | hhhhhhhh | New value of high word |
Description
This opcode sets the higher half of the generic RDP word to wordhi.
Note: the referenced function also generates opcode F1 (which uses wordlo). See the section on F1 for info on that.
0xE2 — G_SETOTHERMODE_L
Argument Mapping
Microcode | Reference Function |
---|---|
E200ssnn dddddddd | gsSPSetOtherMode(0xE2, shift, length, data) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
shift | 32 - shift - length | 32 - (nn + 1) - ss | Amount data is shifted by, or number of LSb of mode bits to be changed |
length | length - 1 | nn + 1 | Size of data affected, in bits |
data | data | dddddddd | New bit settings to be applied |
Description
Modifies various bits of the lower half of the RDP Other Modes word. Various enumerations are provided for shift and data.
The operation performed by the opcode can be expressed as such, assuming LO to stand for the lower word of the RDP other modes:
LO = LO & ~(((1 << length) - 1) << shift) | data
Or, in English, it clears all the bits designated to be modified (determined by shift and length), and then sets those bits according to data. Important to note that data is preshifted. That is, it is up to the caller to shift data appropriately. The enumerations provided for data are pre-shifted to match this requirement.
The enumerations provided for shift are:
- G_MDSFT_ALPHACOMPARE = 0
- G_MDSFT_ZSRCSEL = 2
- G_MDSFT_RENDERMODE = 3
The structure of the lower modes is provided in the main page.
0xE3 — G_SETOTHERMODE_H
Argument Mapping
Microcode | Reference Function |
---|---|
E300ssnn dddddddd | gsSPSetOtherMode(0xE3, shift, length, data) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
shift | 32 - shift - length | 32 - (nn + 1) - ss | Amount data is shifted by, or number of LSb of mode bits to be changed |
length | length - 1 | nn + 1 | Size of data affected, in bits |
data | data | dddddddd | New bit settings to be applied |
Description
Modifies the various bits of the high half of the RDP Other Modes word. Enumerations are provided for shift and data.
Like with E2, data is preshifted, and the opcode's procedure can be formulized in the same way (where OH stands for the high word of the other modes):
HO = HO & ~(((1 << length) - 1) << shift) | data
The enumerations for shift are as follows:
- G_MDSFT_BLENDMASK = 0
- G_MDSFT_ALPHADITHER = 4
- G_MDSFT_RGBDITHER = 6
- G_MDSFT_COMBKEY = 8
- G_MDSFT_TEXTCONV = 9
- G_MDSFT_TEXTFILT = 12
- G_MDSFT_TEXTLUT = 14
- G_MDSFT_TEXTLOD = 16
- G_MDSFT_TEXTDETAIL = 17
- G_MDSFT_TEXTPERSP = 19
- G_MDSFT_CYCLETYPE = 20
- G_MDSFT_COLORDITHER = 22
- G_MDSFT_PIPELINE = 23
The layout of the high word is describe in the main page.
0xE4 — G_TEXRECT
Argument Mapping
Microcode | Reference Function |
---|---|
E4xxxyyy 0iXXXYYY E1000000 sssstttt F1000000 ddddeeee |
gsSPTextureRectangle(ulx, uly, lrx, lry, tile, uls, ult, dsdx, dtdy) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
lrx | lrx | xxx | Lower-right corner X coordinate |
lry | lry | yyy | Lower-right corner Y coordinate |
tile | tile | i | Tile descriptor to use for rectangle |
ulx | ulx | XXX | Upper-left corner X coordinate |
uly | uly | YYY | Upper-left corner Y coordinate |
uls | uls | ssss | Texture S coordinate at upper-left corner |
ult | ult | tttt | Texture T coordinate at upper-left corner |
dsdx | dsdx | dddd | Change in S coordinate over change in X coordinate |
dtdy | dtdy | eeee | Change in T coordinate over change in Y coordinate |
Description
Draws a textured rectangle from screen coordinates (ulx,uly) to (lrx, lry), using the texture specified by tile to color the rectangle. The texture is positioned using (uls, ult) as the texture coordinate of (ulx, uly), and changing the texture coordinates with the use of dsdx and dtdy.
ulx, uly, lrx, and lry are 12-bit numbers in a fixed point 10.2 format, giving a range of 0 ≤ n ≤ 1023.75 for each value (with 0b0.01 / 0d0.25 precision). This means that the coordinates cannot reference the framebuffer past a 1024-pixel square, if the framebuffer exceeds those limits in either dimension.
tile refers to any of the eight tile descriptors whose texture will be used on the rectangle. uls and ult specify the S and T coordinate, respectively, of the upper-left corner of the rectangle. uls and ult are in signed fixed point 10.5 format, giving a range -1024 ≤ n ≤ 1023.96875 for each value (with 0b0.00001 / 1/32 precision).
The texture coordinates for other parts of the rectangle are calculated via dsdx and dtdy, which are in signed fixed point 5.10 format, giving a range of -32 ≤ n ≤ 31.999023 (with 0b0.0000000001 / 1/1024 precision). These parameters change the S coordinate per a change of 1.0 in the X coordinate of the rectangle, and the T coordinate per change of 1.0 in the Y coordinate (XXX not entirely sure on what the 'per change's are, but 1.0 seems reasonable).
Important to note that using this opcode requires setting the texture parameters in the high and low words of the RDP after this opcode, which the given function gsSPTextureRectangle does (extra instructions in italics above).
An alternate version of this command exists as gsDPTextureRectangle. It takes the same parameters, but generates a 128-bit opcode, twice the size of other opcodes:
E4xxxyyy 0iXXXYYY sssstttt ddddeeee
However, this version isn't documented in the SDK's function reference, and it seems to be an outdated or otherwise unusual variant. Therefore this version seems unlikely.
0xE5 — G_TEXRECTFLIP
Argument Mapping
Microcode | Reference Function |
---|---|
E5xxxyyy 0iXXXYYY E1000000 sssstttt F1000000 ddddeeee |
gsSPTextureRectangleFlip(ulx, uly, lrx, lry, tile, uls, ult, dtdx, dsdy) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
lrx | lrx | xxx | Lower-right corner X coordinate |
lry | lry | yyy | Lower-right corner Y coordinate |
tile | tile | i | Tile descriptor to use for rectangle |
ulx | ulx | XXX | Upper-left corner X coordinate |
uly | uly | YYY | Upper-left corner Y coordinate |
uls | uls | ssss | Texture S coordinate at upper-left corner |
ult | ult | tttt | Texture T coordinate at upper-left corner |
dtdx | dtdx | dddd | Change in T coordinate over change in X coordinate |
dsdy | dsdy | eeee | Change in S coordinate over change in Y coordinate |
Description
This is similar to opcode E4, with the only difference being that the S and T coordinates of a texture are flipped in rendering, so that S coordinates are along the Y axis and T along the X axis. This essentially flips the texture about the diagonal line (ulx,uly),(lrx,lry).
dtdx describes the change in T over the change in X, and dsdy describes change in S over change in Y.
Also like E4, there is an unusual 128-bit variant created by gsDPTextureRectangleFlip:
E5xxxyyy 0iXXXYYY sssstttt ddddeeee
0xE6 — G_RDPLOADSYNC
Argument Mapping
Microcode | Reference Function |
---|---|
E6000000 00000000 | gsDPLoadSync() |
No arguments for this opcode
Description
This forces a wait for a texture to load, in order to synchronize with pixel rendering. This ensures that loading a new texture won't disrupt the rendering of primitives mid-render.
0xE7 — G_RDPPIPESYNC
Argument Mapping
Microcode | Reference Function |
---|---|
E7000000 00000000 | gsDPPipeSync() |
No arguments for this opcode
Description
This is not the "start of display list" command. There is no such thing.
Waits for the RDP to finish rendering its currently-rendering primitive, before updating RDP attributes. This avoids altering the rendering of a primitive in the middle of its render.
Historically, several model viewers have interpreted this command as somehow starting a display list. This is not true. Display lists have no command that starts a display list. To find display lists, the most accurate way would be to find the end display list command (DF) and work backwards, until an invalid display list command is encountered.
0xE8 — G_RDPTILESYNC
Argument Mapping
Microcode | Reference Function |
---|---|
E8000000 00000000 | gsDPTileSync() |
No arguments for this opcode
Description
Forces a wait for rendering to finish before updating tile descriptor attributes, so as to not disrupt rendering of primitives mid-render.
0xE9 — G_RDPFULLSYNC
Argument Mapping
Microcode | Reference Function |
---|---|
E9000000 00000000 | gsDPFullSync() |
No arguments for this opcode
Description
Generates an interrupt for the main CPU when the RDP has finished doing everything. This is typically the last opcode before the "end display list" opcode (DF).
0xEA — G_SETKEYGB
Argument Mapping
Microcode | Reference Function |
---|---|
EAwwwxxx ccssddtt | gsDPSetKeyGB(centerG, scaleG, widthG, centerB, scaleB, widthB) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
widthG | widthG | www | Scaled width of half the key window for green |
widthB | widthB | xxx | Scaled width of half the key window for blue |
centerG | centerG | cc | Intensity of active key for green |
scaleG | scaleG | ss | Reciprocal of size of soft edge, normalized to 0..0xFF, for green |
centerB | centerB | dd | Intensity of active key for blue |
scaleB | scaleB | tt | Reciprocal of size of soft edge, normalized to 0..0xFF, for blue |
Description
Sets the center, scale, and width parameters for the green and blue components for chroma key (see EB for red).
widthB and widthG are in an unsigned fixed-point 4.8 format. The other parameters are normal 8-bit unsigned integers.
Note that chroma key was considered unsupported by Oct 1999 documentation, however this opcode may potentially still be used to set registers in the Color Combiner for other purposes.
0xEB — G_SETKEYR
Argument Mapping
Microcode | Reference Function |
---|---|
EB000000 0wwwccss | gsDPSetKeyR(centerR, widthR, scaleR) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
widthR | widthR | www | Scaled with of half the key window for red |
centerR | centerR | cc | Intensity of active key for red |
scaleR | scaleR | ss | Reciprocal of size of soft edge, normalized to 0..0xFF, for blue |
Description
Sets the scale, center, and width parameters for the red component for chroma key (see EA for blue and green).
widthR is an unsigned fixed-point 4.8 number. centerR and sizeR are 8-bit unsigned integers.
Note that chroma key was considered unsupported by Oct 1999 documentation, however this opcode may potentially still be used to set registers in the Color Combiner for other purposes.
0xEC — G_SETCONVERT
Argument Mapping
Microcode | Reference Function |
---|---|
E C 00aa aaaa aaab bbbb bbbb cccc cccc cddd dddd ddee eeee eeef ffff ffff |
gsDPSetConvert(k0, k1, k2, k3, k4, k5) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
k0 | k0 | aa aaaa aaa | K0 term of conversion matrix |
k1 | k1 | b bbbb bbbb | K1 term of conversion matrix |
k2 | k2 | cccc cccc c | K2 term of conversion matrix |
k3 | k3 | ddd dddd dd | K3 term of conversion matrix |
k4 | k4 | ee eeee eee | K4 term of conversion matrix |
k5 | k5 | f ffff ffff | K5 term of conversion matrix |
Description
Sets the terms need to perform conversion from YUV to RGB. All of the parameters are signed 9-bit numbers, with range -256 ≤ k ≤ 255.
Note that YUV support was no longer guaranteed by Oct 1999 documentation, however the K4 and K5 terms could still potentially be used by the Color Combiner.
0xED — G_SETSCISSOR
Argument Mapping
Microcode | Reference Function |
---|---|
EDxxxyyy m0vvvwww | gsDPSetScissor(mode, ulx, uly, lrx, lry) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
ulx | ulx | xxx | Upper-left X coordinate of rectangle |
uly | uly | yyy | Upper-left Y coordinate of rectangle |
mode | mode | m | Interpolation mode setting |
lrx | lrx | vvv | Lower-right X coordinate of rectangle |
lry | lry | www | Lower-right Y coordinate of rectangle |
Description
Sets the scissoring rectangle, with upper-left corner at (ulx, uly), and lower-right corner at (lrx, lry).
The mode setting controls interpolation, if any. Valid values are:
- G_SC_NON_INTERLACE = 0
- G_SC_EVEN_INTERLACE = 2
- G_SC_ODD_INTERLACE = 3
NON_INTERLACE draws all scanlines, while EVEN and ODD draw only even or odd scanlines, respectively.
0xEE — G_SETPRIMDEPTH
Argument Mapping
Microcode | Reference Function |
---|---|
EE000000 zzzzdddd | gsDPSetPrimDepth(z, dz) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
z | z | zzzz | Z value for primitive |
dz | dz | dddd | delta Z value for primitive |
Description
This sets the Z value for the entire primitive to be rendered, when the source for its depth component is set to be taken from this value. (This could be thought of as the depth version of "flat shading".)
z and dz are signed 16-bit values. z sets the actual depth for the primitive, while dz helps rendering of anti-aliased and decal objects (this is usually 0).
0xEF — G_RDPSETOTHERMODE
Argument Mapping
Microcode | Reference Function |
---|---|
EFhhhhhh LLLLLLLL | gsDPSetOtherMode(omodeH, omodeL) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
omodeH | omodeH | hhhhhh | Settings for other mode higher word bits |
omodeL | omodeL | LLLLLLLL | Settings for other mode lower word bits |
Description
Sets the other mode bits of the RDP. omodeH is similar to using E3, and omodeL is similar to using E2.
The difference from either E3 or E2 is that this command sets all the bits in both halves of the RDP word (that is, this opcode has no way of limiting what bits are actually affected).
See the main page for what the other mode bits mean
0xF0 — G_LOADTLUT
Argument Mapping
Microcode | Reference Function |
---|---|
F0000000 0tccc000 | gsDPLoadTLUTCmd(tile, count) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
tile | tile | t | Tile descriptor to load from |
count | (count & 0x3FF) << 2 | ccc >> 2 | Number of colors to load minus one |
Description
Tells the RDP to load count + 1 colors from the texture loaded to tile descriptor tile. The tile descriptor's attributes and other state related to textures inform the RDP how to load the palette, and where to load it to.
(Note: the count is quadrupled likely due to how palettes are stored in TMEM. Not sure where details on that would be appropriate, though.)
0xF1 — G_RDPHALF_2
Argument Mapping
Microcode | Reference Function |
---|---|
F1000000 LLLLLLLL | gsDPWord(wordhi, wordlo) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
wordlo | wordlo | LLLLLLLL | New value of low word |
Description
This opcode sets the low half of the generic RDP word to wordlo.
Note: the referenced function also generates opcode E1 (which uses wordhi). See the section on E1 for info on that.
0xF2 — G_SETTILESIZE
Argument Mapping
Microcode | Reference Function |
---|---|
F2sssttt 0iuuuvvv | gsDPSetTileSize(tile, uls, ult, lrs, lrt) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
uls | uls | sss | Upper-left texture coordinate, S-axis |
ult | ult | ttt | Upper-left texture coordinate, T-axis |
tile | tile | i | Tile descriptor to modify |
lrs | lrs | uuu | Lower-right texture coordinate, S-axis |
lrt | lrt | vvv | Lower-right texture coordinate, T-axis |
Description
Sets the size of the texture for tile descriptor tile, setting its upper-left corner at (uls, ult), and its lower-right corner at lrs, lrt.
When loading textures into TMEM, these values indicate the location of the first and last texel to load into TMEM. When rendering, the upper-left corner tells where in texture image space to start taking the texture from, while the lower-right corner applies in rendering only for clamping the texture.
uls, ult, lrs, and lrt are all in unsigned fixed-point 10.2 format, with range 0 ≤ x ≤ 1023.75
0xF3 — G_LOADBLOCK
Argument Mapping
Microcode | Reference Function |
---|---|
F3sssttt 0ixxxddd | gsDPLoadBlock(tile, uls, ult, texels, dxt) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
uls | uls | sss | Upper-left corner of texture to load, S-axis |
ult | ult | ttt | Upper-left corner of texture to load, T-axis |
tile | tile | i | Tile descriptor to load into |
texels | texels | xxx | Number of texels to load to TMEM, minus one |
dxt | dxt | ddd | Change in T-axis per scanline |
Description
Loads a texture into TMEM as one long line of data, starting at (uls, ult) in the currently chosen area of RAM, and loads texels + 1 texels to TMEM for tile descriptor tile. dxt is used for determining when the next row starts.
uls and ult are unsigned fixed-point 10.2 numbers, with range 0 ≤ n ≤ 1023.75.
dxt is an unsigned fixed-point 1.11 number, meaning a range of 0 ≤ n ≤ 1.999512. This number has units, namely lines words-1, where a "word" is 64 bits in length, and a line is one row of the texture. (It may be more easily understood when inverted to get its reciprocal: words/lines . dxt is the reciprocal of the number of 64-bit chunks it takes to get a row of texture.)
When loading an image through this opcode, an internal counter is incremented by dxt for every 64 bits of texture read. When this counter is high enough to turn over to the next integer value (e.g. 0.9 + 0.15 -> 1.05), the current line number is incremented. This is important as odd-numbered rows have their values swapped for interleaved access (the first line read in is line 0, and thus isn't swapped).
Note that if dxt is not a power of two (i.e. only one bit in the value is 'on'), then an error in the counter will accumulate over time, and eventually cause errors in determining where next lines are (when exactly this happens depends on the value and the type of texture being read in).
If the data has bee pre-interleaved by the game, then dxt will be 0, meaning the current line number never advances (and thus loading will never interleave data for you).
0xF4 — G_LOADTILE
Argument Mapping
Microcode | Reference Function |
---|---|
F4sssttt 0iuuuvvv | gsDPLoadTile(tile, uls, ult, lrs, lrt) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
uls | uls | sss | Upper-left corner of tile, S-axis |
ult | ult | ttt | Upper-left corner of tile, T-axis |
tile | tile | i | Tile descriptor being loaded to |
lrs | lrs | uuu | Lower-right corner of tile, S-axis |
lrt | lrt | vvv | Lower-right corner of tile, T-axis |
Description
Loads a rectangular portion of the texture being pointed to in DRAM for tile descriptor tile into TMEM. (uls, ult) specifies the upper-left corner of the texture in RAM, offset from its earlier-specified origin, and (lrs, lrt) specifies the lower-right corner of the texture to load.
All coordinate values are in unsigned fixed-point 10.2 format (range 0 ≤ n ≤ 1023.75).
0xF5 — G_SETTILE
Argument Mapping
Microcode | Reference Function |
---|---|
F 5 fffi i0nn nnnn nnnm mmmm mmmm 0000 0ttt pppp ccaa aass ssdd bbbb uuuu |
gsDPSetTile(fmt, siz, line, tmem, tile, palette, cmT, maskT, shiftT, cmS, maskS, shiftS) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
fmt | fmt | fff | Sets color format |
siz | siz | i i | Sets bit size of pixel |
line | line | nn nnnn nnn | Number of 64-bit values per row |
tmem | tmem | m mmmm mmmm | Offset of texture in TMEM |
tile | tile | ttt | Tile descriptor being modified |
palette | palette | pppp | Which palette to use for colors (if relevant) |
cmT | cmT | cc | Clamp and Mirror flags for the T axis |
maskT | maskT | aa aa | Sets how much of T axis is shown before wrapping |
shiftT | shiftT | ss ss | Sets the amount to shift T axis values after perspective division |
cmS | cmS | dd | Clamp and Mirror flags for the S axis |
maskS | maskS | bbbb | Sets how much of S axis is shown before wrapping |
shiftS | shiftS | uuuu | Sets the amount to shift S axis values after perspective division |
Description
Sets many different parameters for tile descriptor tile.
fmt sets the color format in use by the particular texture. It can be one of these values:
- G_IM_FMT_RGBA = 0
- G_IM_FMT_YUV = 1
- G_IM_FMT_CI = 2
- G_IM_FMT_IA = 3
- G_IM_FMT_I = 4
siz sets the bit size of each texel. It can be any of these:
- G_IM_SIZ_4b = 0
- G_IM_SIZ_8b = 1
- G_IM_SIZ_16b = 2
- G_IM_SIZ_32b = 3
(Not every combination of fmt and siz is valid. See below(?) for a table of accepted texture types.)
line sets the number of 64-bit pieces per row of the texture (textures will be padded in TMEM if the row doesn't end in a multiple of 64 bits). tmem is the location in TMEM where the texture is. Note that TMEM is addressed in units of 64 bits here (zero-indexed), so e.g. 1 means byte 8 of TMEM.
palette specifies which of the sixteen palettes this texture will be using. Note that this only applies to ci4 textures (G_IM_FMT_CI and G_IM_SIZ_4b), since ci8 has access to the entirety of the palette area, and no other texture type needs palettes.
cmT and cmS set the clamp and mirror settings for their respective axes. The values of these two parameters can be any combination of:
- G_TX_NOMIRROR = 0
- G_TX_MIRROR = 1
- G_TX_WRAP = 0
- G_TX_CLAMP = 2
Where NOMIRROR and MIRROR, and WRAP and CLAMP are exclusive pairs of options. (And with NOMIRROR and WRAP currently labeled just to allow explicitly stating desired operation.) MIRROR enables mirroring of the texture along that given access (e.g. setting MIRROR for the S axis will mirror a texture horizontally), whereas NOMIRROR disables it. WRAP repeats texels on a particular cycle, whereas CLAMP enforces clamping instead (sampling the colors at the edges of the texture for texels beyond the set size of the texture).
maskT and maskS sets when the respective axis "loops" its texels. the value is interpreted as the first bit that's ignored. In other words, only the first 2mask texels of the row/column are actually used. If wrapping, then the previous texels are simply repeated; mirroring will mirror the set to be reperated, meaning the maskth bit of the current coordinate decides if its texel is mirrored. A mask value of 0 will implicitly enable clamping.
shiftT and shiftS specify how many bits to shift texture coordinates after perspective division, for their respective axes. If the value is 0, then no shifting is done. If the value is in range 1 ≤ n ≤ 10, then coordinates are right-shifted by that amount. For values in range 11 ≤ n ≤ 15, values are left-shifted by 16 - n.
0xF6 — G_FILLRECT
Argument Mapping
Microcode | Reference Function |
---|---|
F6xxxyyy 00vvvwww | gsDPFillRectangle(ulx, uly, lrx, lry) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
lrx | (lrx & 0x3FF) << 2 | xxx | Lower-right corner of rectangle, X-axis |
lry | (lry & 0x3FF) << 2 | yyy | Lower-right corner of rectangle, Y-axis |
ulx | (ulx & 0x3FF) << 2 | vvv | Upper-left corner of rectangle, X-axis |
uly | (uly & 0x3FF) << 2 | www | Upper-left corner of rectangle, Y-axis |
Description
Draws a rectangle to the framebuffer with top-left corner (ulx, uly) and bottom-right corner (lrx, lry), coloring it with the current fill color. Similar to E4, but uses a solid color instead of a texture.
All the coordinate values are (probably) fixed-width unsigned 10.2 format, with the macro shown making sure the coordinates sent to microcode are integers.
0xF7 — G_SETFILLCOLOR
Argument Mapping
Microcode | Reference Function |
---|---|
F7000000 cccccccc | gsDPSetFillColor(color) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
color | color | cccccccc | Fill value for use in fill mode |
Description
Sets the fill color for use in fill mode, which allows clearing the current color buffer.
When clearing the Z buffer, color is a 14-bit Z value and 2-bit dZ value specified twice to fill all 32 bits. In other words, color at the bit level looks like the following:
ZZZZ ZZZZ ZZZZ ZZdd ZZZZ ZZZZ ZZZZ ZZdd
If dealing with a color buffer, the meaning of color depends on the current color image's format. For an RGBA5551 color image, the chosen fill color is specified twice, like with the Z buffer:
rrrr rggg ggbb bbba rrrr rggg ggbb bbba
For an RGBA32 color image, color is a single RGBA32 color value.
For the 16-bit versions, the two occurrences of the color/depth value should be the same, however they can be different for an unspecified "special effect".
(Note: there is one reference to being able to use an 8-bit color image, but it's not clear if that applies here. Could the Video Interface settings be related in some way as well?)
0xF8 — G_SETFOGCOLOR
Argument Mapping
Microcode | Reference Function |
---|---|
F8000000 rrggbbaa | gsDPSetFogColor(R, G, B, A) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
R | R | rr | Red component of fog color |
G | G | gg | Green component of fog color |
B | B | bb | Blue component of fog color |
A | A | aa | Alpha component of fog color |
Description
Sets the fog color in the RDP blender. It's considered a general-purpose register, which as the name suggests is typically intended for fog effects. Note that the fog color is always specified in RGBA32 form, regardless of actual framebuffer formats.
0xF9 — G_SETBLENDCOLOR
Argument Mapping
Microcode | Reference Function |
---|---|
F9000000 rrggbbaa | gsDPBlendColor(R, G, B, A) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
R | R | rr | Red component of blend color |
G | G | gg | Green component of blend color |
B | B | bb | Blue component of blend color |
A | A | aa | Alpha component of blend color |
Description
Sets the RDP blender's blend color, a general purpose color register available for various purposes in the blender.
0xFA — G_SETPRIMCOLOR
Argument Mapping
Microcode | Reference Function |
---|---|
FA00mmff rrggbbaa | gsDPSetPrimColor(minlevel, lodfrac, R, G, B, A) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
minlevel | minlevel | mm | Minimum possible LOD value (clamped to this at minimum) |
lodfrac | lodfrac | ff | Primitive LOD fraction for mipmap filtering |
R | R | rr | Red component of primitive color |
G | G | gg | Green component of primitive color |
B | B | bb | Blue component of primitive color |
A | A | aa | Alpha component of primitive color |
Description
Sets the primitive color register of the RDP's color combiner. Also sets two additional values available to the color combiner, the minimum LOD level and an LOD fraction.
minlevel and lodfrac are both fixed-point unsigned 0.8 numbers, meaning a range of 0 ≤ n ≤ 0.99609375. minlevel defines the minimum possible value for LOD to have, when the LOD calculated for a particular part of the primitive is less than 1.0. In other words, the LOD of any part of the primitive is clamped at the lower end to max(minlevel, LOD).
lodfrac specifies a fraction that the programmer can specify for use in the color combiner of the RDP. It's meant to offer a further refinement (XXX verify that, not 100% sure on it) on the linear filtering of two mipmaps. (Typically referred to in the SDK and elsewhere as "trilinear" filtering; however, due to the potential ambiguity of this term, we won't use it here. See the note on terminology at [1].)
The RGBA32 color specified via R, G, B, and A is also made available to the color combiner for use by the programmer.
0xFB — G_SETENVCOLOR
Argument Mapping
Microcode | Reference Function |
---|---|
FB000000 rrggbbaa | gsDPSetEnvColor(R, G, B, A) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
R | R | rr | Red component of environment color |
G | G | gg | Green component of environment color |
B | B | bb | Blue component of environment color |
A | A | aa | Alpha component of environment color |
Description
Sets the environment color register in the RDP's color combiner. It's available as a general-purpose color register for the programmer to use in the color combiner.
0xFC — G_SETCOMBINE
Argument Mapping
Microcode | Reference Function |
---|---|
F C aaaa cccc czzz xxxe eeeg gggg bbbb ffff vvvt ttdd dyyy wwwh hhuu usss |
gsDPSetCombineLERP(a0, b0, c0, d0, Aa0, Ab0, Ac0, Ad0, a1, b1, c1, d1, Aa1, Ab1, Ac1, Ad1) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
a0 | a0 | aaaa | Color 'a' value, first cycle |
c0 | c0 | cccc c | Color 'c' value, first cycle |
Aa0 | Aa0 | zzz | Alpha 'a' value, first cycle |
Ac0 | Ac0 | xxx | Alpha 'c' value, first cycle |
a1 | a1 | eee e | Color 'a' value, second cycle |
c1 | c1 | g gggg | Color 'c' value, second cycle |
b0 | b0 | bbbb | Color 'b' value, first cycle |
b1 | b1 | ffff | Color 'b' value, second cycle |
Aa1 | Aa1 | vvv | Alpha 'a' value, second cycle |
Ac1 | Ac1 | t tt | Alpha 'c' value, second cycle |
d0 | d0 | dd d | Color 'd' value, first cycle |
Ab0 | Ab0 | yyy | Alpha 'b' value, first cycle |
Ad0 | Ad0 | www | Alpha 'd' value, first cycle |
d1 | d1 | h hh | Color 'd' value, second cycle |
Ab1 | Ab1 | uu u | Alpha 'b' value, second cycle |
Ad1 | Ad1 | sss | Alpha 'd' value, second cycle |
Description
Sets up the RDP's Color Combiner's parameters for primitive rendering. This sets up parameters for color (R, G, B) and alpha for both cycles. (In one-cycle mode, both cycles must have equal parameters.)
The general formula used to mix colors in the Color combiner is of the form:
(A - B) * C + D
This is performed on all sets of parameters. a0, b0, c0, and d0; a1, b1, c1, and d1; Aa0, Ab0, Ac0, and Ad0; and Aa1, Ab1, Ac1, and Ad1 are those sets of parameters.
The values taken in each parameter are part of an enumeration of potential sources for that value, but which differs for various pieces: all of the color A, B, C, D components have different enumerations, and alpha C is different from the other alpha components. See the main page on the color combiner for details on how it works.
0xFD — G_SETTIMG
Argument Mapping
Microcode | Reference Function |
---|---|
FD__0www iiiiiiii __ -> fffs s000 (binary) |
gsDPSetTextureImage(fmt, siz, width, imgaddr) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
fmt | fmt | fff | Format of texture to be pointed to |
siz | siz | ss | Bit size of pixels in texture to be pointed to |
width | width - 1 | www + 1 | Width of the texture |
imgaddr | imgaddr | iiiiiiii | RAM address of start of texture |
Description
This opcode sets the location in RAM of the image that will be used when using any of the texture loading opcodes. imgaddr is the RAM location of the image to be pulling textures from. width is the width of the image, necessary in finding out when next rows start. The maximum allowed with is 4096, or 0x1000. www is the width minus one so that it can fit within three nybbles.
fmt and siz are the usual image format enumerations, explained on the main page.
0xFE — G_SETZIMG
Argument Mapping
Microcode | Reference Function |
---|---|
FE000000 iiiiiiii | gsDPSetDepthImage(imgaddr) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
imgaddr | imgaddr | iiiiiiii | Address of the depth buffer |
Description
Sets the location of the depth buffer to imgaddr. Since the format of the depth buffer is fixed (14-bit Z value and 2-bit dZ value), those parameters are not here, unlike for FD and FF. The width of the depth buffer is shared with the color buffer (see FF), and thus isn't set here.
0xFF — G_SETCIMG
Argument Mapping
Microcode | Reference Function |
---|---|
FF__0www iiiiiiii __ -> fffs s000 (binary) |
gsDPSetColorImage(fmt, siz, width, imgaddr) |
Function Param | To Microcode | From Microcode | Explanation |
---|---|---|---|
fmt | fmt | fff | Format of color buffer to be pointed to |
siz | siz | ss | Bit size of pixels in color buffer to be pointed to |
width | width - 1 | www + 1 | Width of the color buffer |
imgaddr | imgaddr | iiiiiiii | RAM address of color buffer |
Description
Sets the location of the color framebuffer, usually a framebuffer that's displayed to the screen. The color buffer is set to RAM location imgaddr, with a width of width. fmt and siz are the typical image format enumerations, described on the main page.
The location is usually some place set as the framebuffer to show (which is not handled by display lists), but oftentimes will be set to a depth buffer. This is usually done to fill (aka clear) the depth buffer in fill mode.