Struct ClassicQuadTexturedGouraud 

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

    pub tag: 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,
}

Classic textured Gouraud quad without inline texture-window state. This is the compact GP0(3Ch) packet paired with ClassicTriTexturedGouraud. 13 words (tag + 12 data).

Fields

tag: u32

Staged OT tag or final DMA linkage.

color0_cmd: u32

GP0(3Ch) plus vertex-zero RGB.

v0: u32

Vertex-zero screen coordinate.

uv0_clut: u32

Vertex-zero UV and CLUT.

color1: u32

Vertex-one RGB.

v1: u32

Vertex-one screen coordinate.

uv1_tpage: u32

Vertex-one UV and tpage.

color2: u32

Vertex-two RGB.

v2: u32

Vertex-two screen coordinate.

uv2: u32

Vertex-two UV.

color3: u32

Vertex-three RGB.

v3: u32

Vertex-three screen coordinate.

uv3: u32

Vertex-three UV.

Implementations

impl ClassicQuadTexturedGouraud

pub const WORDS: u8 = 12

Data-word count after the tag.

pub const fn with_staged_slot( verts: [(i16, i16); 4], uv_words: [u16; 4], colors: [u32; 4], clut: u16, tpage: u16, ot_slot: u16, ) -> Self

Build a compact packet with a staged OT slot.

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

Build a staged compact packet from CLUT and tpage words that have already been shifted into their GP0 high-halfword positions.

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, ot_slot: u16, ) -> Self

Build a staged packet without masking the supplied packet RGB words.

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, 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.

Trait Implementations

impl Clone for ClassicQuadTexturedGouraud

fn clone(&self) -> ClassicQuadTexturedGouraud

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ClassicQuadTexturedGouraud

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

Formats the value using the given formatter.

impl GpuPacket for ClassicQuadTexturedGouraud

const WORDS: u8 = ClassicQuadTexturedGouraud::WORDS

Payload words after the tag.

impl Hash for ClassicQuadTexturedGouraud

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 ClassicQuadTexturedGouraud

fn eq(&self, other: &ClassicQuadTexturedGouraud) -> 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 ClassicQuadTexturedGouraud

impl Eq for ClassicQuadTexturedGouraud

impl StructuralPartialEq for ClassicQuadTexturedGouraud