Struct QuadTexturedGouraud 

#[repr(C, align(4))]
pub struct QuadTexturedGouraud {

    pub tag: u32,
    pub tex_window: u32,
    pub color0_cmd: u32,
    pub v0: u32,
    pub uv0_clut: u32,
    pub color1: u32,
    pub v1: u32,
    pub uv1_tpage: u32,
    pub color2: u32,
    pub v2: u32,
    pub uv2: u32,
    pub color3: u32,
    pub v3: u32,
    pub uv3: u32,
}

Textured Gouraud quad with inline texture-window state. Mirrors TriTexturedGouraud extended to four vertices: GP0(E2) texture-window state immediately followed by the GP0(3Ch) Gouraud-textured-quad command. Per-vertex RGB modulates the sampled texel exactly like the triangle. 14 words (tag + 13 data).

The PS1 GPU rasterizes this quad as the two triangles (v0,v1,v2) and (v1,v2,v3) – the 1-2 diagonal. A caller whose engine splits quads on the 0-2 diagonal as tri(a,b,c)+tri(a,c,d) must reorder its perimeter [a,b,c,d] to [b,a,c,d] before building the packet so the hardware split lands on the same edge; that yields pixel-identical output (proved by textured_gouraud_quad_matches_two_triangle_split_bitexact in the emulator GPU tests).

Fields

tag: u32

OT linkage.

tex_window: u32

GP0(E2) texture-window command.

color0_cmd: u32

0x3C000000 | color0 header – v0’s RGB shares the opcode word.

v0: u32

Vertex 0 position.

uv0_clut: u32

(u0, v0, clut) packed.

color1: u32

Vertex 1 colour.

v1: u32

Vertex 1 position.

uv1_tpage: u32

(u1, v1, tpage) packed.

color2: u32

Vertex 2 colour.

v2: u32

Vertex 2 position.

uv2: u32

(u2, v2, 0) packed.

color3: u32

Vertex 3 colour.

v3: u32

Vertex 3 position.

uv3: u32

(u3, v3, 0) packed.

Implementations

impl QuadTexturedGouraud

pub const WORDS: u8 = 13

Data-word count (tag excluded).

pub const EMPTY: Self

Zeroed packet for static prebuilt-pool initialisation. Real content is written by the first draw of each surface before the packet ever links into an ordering table (per-surface validity bytes guarantee it).

pub const fn with_material( verts: [(i16, i16); 4], uvs: [(u8, u8); 4], colors: [(u8, u8, u8); 4], material: TextureMaterial, ) -> Self

Build a textured Gouraud quad from per-vertex UVs and a TextureMaterial. Vertex order is TL, TR, BL, BR; each colour tints its vertex ((128, 128, 128) leaves texels unmodulated).

pub const fn with_packet_material_packed_uv_words( verts: [(i16, i16); 4], uv_words: [u16; 4], colors: [(u8, u8, u8); 4], material: TexturedGouraudPacketMaterial, ) -> Self

Build a textured Gouraud quad from UV words and a packet material precomputed for a hot material, mirroring TriTexturedGouraud::with_packet_material_packed_uv_words.

pub const fn with_staged_slot_prepacked_colors( verts: [(i16, i16); 4], uv_words: [u16; 4], colors: [u32; 4], clut_high_word: u32, tpage_high_word: u32, texture_window_word: u32, ot_slot: u16, ) -> Self

Build a self-contained texture-window packet whose tag temporarily carries ot_slot for a later tagged-stream OT linking pass.

Every color word must have its high byte clear, and clut_high_word and tpage_high_word must hold only their high halfwords; debug builds assert both. A word that breaks this changes what the GPU draws, not memory, so the constructor is safe.

pub const unsafe fn with_staged_slot_prepacked_unchecked( verts: [(i16, i16); 4], uv_words: [u16; 4], colors: [u32; 4], clut_high_word: u32, tpage_high_word: u32, texture_window_word: u32, ot_slot: u16, ) -> Self

👎Deprecated:

renamed to with_staged_slot_prepacked_colors, which is safe

Renamed to Self::with_staged_slot_prepacked_colors, which is safe.

Safety

Nothing beyond that function’s preconditions; it stays unsafe so existing unsafe blocks keep compiling without a warning.

pub fn set_positions(&mut self, verts: [(i16, i16); 4])

Rewrite the four vertex words of a prebuilt packet, leaving every material/UV/colour word untouched. This is the per-frame patch for precompiled static world geometry.

pub fn copy_payload_from(&mut self, source: &Self)

Copy every packet word except the OT tag from a prebuilt skeleton. The destination can then patch positions and link into an ordering table without inheriting a stale DMA link.

pub fn set_colors(&mut self, colors: [(u8, u8, u8); 4])

Rewrite the four colour words of a prebuilt packet, preserving the opcode byte that shares v0’s colour word.

Trait Implementations

impl Clone for QuadTexturedGouraud

fn clone(&self) -> QuadTexturedGouraud

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for QuadTexturedGouraud

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl GpuPacket for QuadTexturedGouraud

const WORDS: u8 = QuadTexturedGouraud::WORDS

Payload words after the tag.

impl Hash for QuadTexturedGouraud

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given [Hasher].

impl PartialEq for QuadTexturedGouraud

fn eq(&self, other: &QuadTexturedGouraud) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for QuadTexturedGouraud

impl Eq for QuadTexturedGouraud

impl StructuralPartialEq for QuadTexturedGouraud