use crate::core::drawing::RaylibDraw;
use crate::ffi;
use crate::ffi::Color;

/// Primitive type for an immediate-mode vertex stream (`rlBegin`).
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DrawMode {
    /// Line list (`RL_LINES`).
    Lines = ffi::RL_LINES as i32,
    /// Triangle list (`RL_TRIANGLES`).
    Triangles = ffi::RL_TRIANGLES as i32,
    /// Quad list (`RL_QUADS`).
    Quads = ffi::RL_QUADS as i32,
}

use crate::core::drawing::RaylibDraw;
use crate::ffi;
use crate::math::Matrix;

/// Target matrix for `rl_matrix_mode`.
#[repr(i32)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum MatrixMode {
    /// Model-view matrix (`RL_MODELVIEW`).
    ModelView = ffi::RL_MODELVIEW as i32,
    /// Projection matrix (`RL_PROJECTION`).
    Projection = ffi::RL_PROJECTION as i32,
    /// Texture matrix (`RL_TEXTURE`).
    Texture = ffi::RL_TEXTURE as i32,
}

use crate::core::drawing::RaylibDraw;
use crate::core::shaders::Shader;
use crate::core::texture::Texture2D;
use crate::ffi;

//! Safe wrappers for rlgl's immediate-mode drawing layer (the GL abstraction
//! beneath raylib's modules; wraps `rlgl.h`). Covers the matrix stack, immediate-
//! mode vertex streams, a few render-state toggles, and ergonomic methods that
//! bind the crate's safe [`Texture2D`](crate::core::texture::Texture2D) /
//! [`Shader`](crate::core::shaders::Shader) handles. GL-object *lifecycle*
//! (create/destroy) stays with those safe types and raw [`ffi`](crate::ffi); the
//! full 161-fn rlgl surface remains available there as a power-user escape hatch.
//!
//! All entry points hang off the draw-handle types (via [`RaylibRlgl`]), so they
//! are only callable inside a `begin_drawing` frame.

mod immediate;
mod matrix;
mod state;

pub use immediate::{DrawMode, RlImmediate};
pub use matrix::{MatrixMode, RlMatrix};

use crate::core::drawing::RaylibDraw;

/// Immediate-mode rlgl drawing, available on every draw handle. See the module docs.
pub trait RaylibRlgl: RaylibDraw + Sized {
    // Filled in Tasks 2–4.
}

impl<D: RaylibDraw> RaylibRlgl for D {}

pub mod rlgl;

pub use crate::rlgl::*;

/// RAII guard for an immediate-mode vertex stream: `rlBegin` on creation,
/// `rlEnd` on drop. Vertex/color methods (Task 3) live here so they cannot be
/// called outside a `rlBegin`/`rlEnd` block.
pub struct RlImmediate<'a, T: RaylibDraw>(&'a mut T);

impl<'a, T: RaylibDraw> Drop for RlImmediate<'a, T> {
    fn drop(&mut self) {
        // SAFETY: paired with the `rlBegin` that created this guard; raylib's
        // rlgl tolerates rlEnd after rlBegin on the active batch.
        unsafe { ffi::rlEnd() }
    }
}

/// RAII guard for a pushed matrix: `rlPushMatrix` on creation, `rlPopMatrix` on
/// drop. Deref's to the draw handle so you can keep drawing within the pushed
/// transform. Transform methods (Task 2) are on the [`RaylibRlgl`] trait.
pub struct RlMatrix<'a, T: crate::core::drawing::RaylibDraw>(&'a mut T);

impl<'a, T: crate::core::drawing::RaylibDraw> Drop for RlMatrix<'a, T> {
    fn drop(&mut self) {
        // SAFETY: paired with the `rlPushMatrix` that created this guard.
        unsafe { ffi::rlPopMatrix() }
    }
}

impl<'a, T: crate::core::drawing::RaylibDraw> std::ops::Deref for RlMatrix<'a, T> {
    type Target = T;
    fn deref(&self) -> &T {
        self.0
    }
}
impl<'a, T: crate::core::drawing::RaylibDraw> std::ops::DerefMut for RlMatrix<'a, T> {
    fn deref_mut(&mut self) -> &mut T {
        self.0
    }
}

cargo build -p raylib

git add raylib/src/rlgl raylib/src/lib.rs raylib/src/prelude.rs
git commit -m "feat(ws5b): rlgl module skeleton — DrawMode/MatrixMode, RaylibRlgl, guards

Refs #234, #179 (rlgl safe bindings).

Co-Authored-By: Claude Opus 4.7 <[email protected]>"

    /// Push the current matrix onto the stack; the returned guard pops it on drop.
    /// Apply transforms (`rl_translatef`/`rl_rotatef`/`rl_scalef`) through the guard.
    #[inline]
    fn rl_push_matrix(&mut self) -> RlMatrix<'_, Self> {
        // SAFETY: the returned RlMatrix's Drop calls the matching rlPopMatrix.
        unsafe { ffi::rlPushMatrix() };
        RlMatrix::new(self)
    }
    /// Reset the current matrix to identity.
    #[inline]
    fn rl_load_identity(&mut self) {
        unsafe { ffi::rlLoadIdentity() }
    }
    /// Multiply the current matrix by a translation.
    #[inline]
    fn rl_translatef(&mut self, x: f32, y: f32, z: f32) {
        unsafe { ffi::rlTranslatef(x, y, z) }
    }
    /// Multiply the current matrix by a rotation of `angle` degrees about (x,y,z).
    #[inline]
    fn rl_rotatef(&mut self, angle: f32, x: f32, y: f32, z: f32) {
        unsafe { ffi::rlRotatef(angle, x, y, z) }
    }
    /// Multiply the current matrix by a scale.
    #[inline]
    fn rl_scalef(&mut self, x: f32, y: f32, z: f32) {
        unsafe { ffi::rlScalef(x, y, z) }
    }
    /// Multiply the current matrix by `mat`.
    #[inline]
    fn rl_mult_matrixf(&mut self, mat: crate::math::Matrix) {
        let m: [f32; 16] = mat.to_array();
        unsafe { ffi::rlMultMatrixf(m.as_ptr()) }
    }
    /// Choose which matrix subsequent operations affect.
    #[inline]
    fn rl_matrix_mode(&mut self, mode: MatrixMode) {
        unsafe { ffi::rlMatrixMode(mode as i32) }
    }
    /// Multiply the current matrix by an orthographic projection.
    #[inline]
    fn rl_ortho(&mut self, left: f64, right: f64, bottom: f64, top: f64, near: f64, far: f64) {
        unsafe { ffi::rlOrtho(left, right, bottom, top, near, far) }
    }
    /// Set the projection matrix directly.
    #[inline]
    fn rl_set_matrix_projection(&mut self, proj: crate::math::Matrix) {
        unsafe { ffi::rlSetMatrixProjection(proj.into()) }
    }
    /// Set the model-view matrix directly.
    #[inline]
    fn rl_set_matrix_modelview(&mut self, view: crate::math::Matrix) {
        unsafe { ffi::rlSetMatrixModelview(view.into()) }
    }

impl<'a, T: crate::core::drawing::RaylibDraw> RlMatrix<'a, T> {
    pub(crate) fn new(parent: &'a mut T) -> Self {
        RlMatrix(parent)
    }
}

cargo build -p raylib

git add raylib/src/rlgl
git commit -m "feat(ws5b): rlgl matrix stack — RlMatrix guard + transform/projection methods

Co-Authored-By: Claude Opus 4.7 <[email protected]>"

    /// Begin an immediate-mode vertex stream; the returned guard ends it on drop.
    /// Emit vertices/colors through the guard. Prefer [`rl_draw`](RaylibRlgl::rl_draw).
    #[inline]
    fn rl_begin(&mut self, mode: DrawMode) -> RlImmediate<'_, Self> {
        // SAFETY: the returned RlImmediate's Drop calls the matching rlEnd.
        unsafe { ffi::rlBegin(mode as i32) };
        RlImmediate::new(self)
    }
    /// Run `body` inside an immediate-mode block, ending it afterwards (closure form).
    #[inline]
    fn rl_draw(&mut self, mode: DrawMode, body: impl FnOnce(&mut RlImmediate<'_, Self>)) {
        let mut v = self.rl_begin(mode);
        body(&mut v);
    }

impl<'a, T: RaylibDraw> RlImmediate<'a, T> {
    pub(crate) fn new(parent: &'a mut T) -> Self {
        RlImmediate(parent)
    }
    /// Emit a 2D vertex.
    #[inline]
    pub fn vertex2f(&mut self, x: f32, y: f32) {
        unsafe { ffi::rlVertex2f(x, y) }
    }
    /// Emit a 3D vertex.
    #[inline]
    pub fn vertex3f(&mut self, x: f32, y: f32, z: f32) {
        unsafe { ffi::rlVertex3f(x, y, z) }
    }
    /// Set the current vertex color (8-bit RGBA).
    #[inline]
    pub fn color4ub(&mut self, color: impl Into<Color>) {
        let c = color.into();
        unsafe { ffi::rlColor4ub(c.r, c.g, c.b, c.a) }
    }
    /// Set the current vertex color (float RGB).
    #[inline]
    pub fn color3f(&mut self, r: f32, g: f32, b: f32) {
        unsafe { ffi::rlColor3f(r, g, b) }
    }
    /// Set the current vertex color (float RGBA).
    #[inline]
    pub fn color4f(&mut self, r: f32, g: f32, b: f32, a: f32) {
        unsafe { ffi::rlColor4f(r, g, b, a) }
    }
    /// Set the current texture coordinate.
    #[inline]
    pub fn texcoord2f(&mut self, x: f32, y: f32) {
        unsafe { ffi::rlTexCoord2f(x, y) }
    }
    /// Set the current normal vector.
    #[inline]
    pub fn normal3f(&mut self, x: f32, y: f32, z: f32) {
        unsafe { ffi::rlNormal3f(x, y, z) }
    }
}

    /// # Example
    /// ```no_run
    /// use raylib::prelude::*;
    /// fn frame(d: &mut RaylibDrawHandle) {
    ///     d.rl_draw(DrawMode::Triangles, |v| {
    ///         v.color4ub(Color::RED);
    ///         v.vertex2f(0.0, 0.0);
    ///         v.vertex2f(100.0, 0.0);
    ///         v.vertex2f(50.0, 100.0);
    ///     });
    /// }
    /// ```

cargo build -p raylib
cargo test -p raylib --doc rlgl

git add raylib/src/rlgl
git commit -m "feat(ws5b): rlgl immediate mode — RlImmediate guard + rl_begin/rl_draw

Co-Authored-By: Claude Opus 4.7 <[email protected]>"

    /// Enable depth testing.
    #[inline]
    fn rl_enable_depth_test(&mut self) {
        unsafe { ffi::rlEnableDepthTest() }
    }
    /// Disable depth testing.
    #[inline]
    fn rl_disable_depth_test(&mut self) {
        unsafe { ffi::rlDisableDepthTest() }
    }
    /// Enable back-face culling.
    #[inline]
    fn rl_enable_backface_culling(&mut self) {
        unsafe { ffi::rlEnableBackfaceCulling() }
    }
    /// Disable back-face culling.
    #[inline]
    fn rl_disable_backface_culling(&mut self) {
        unsafe { ffi::rlDisableBackfaceCulling() }
    }
    /// Set the active texture for subsequent immediate-mode drawing.
    #[inline]
    fn rl_set_texture(&mut self, texture: &crate::core::texture::Texture2D) {
        unsafe { ffi::rlSetTexture(texture.id) }
    }
    /// Enable a texture (by binding the safe handle's GL id).
    #[inline]
    fn rl_enable_texture(&mut self, texture: &crate::core::texture::Texture2D) {
        unsafe { ffi::rlEnableTexture(texture.id) }
    }
    /// Disable the active texture.
    #[inline]
    fn rl_disable_texture(&mut self) {
        unsafe { ffi::rlDisableTexture() }
    }
    /// Select the active multitexture slot.
    #[inline]
    fn rl_active_texture_slot(&mut self, slot: i32) {
        unsafe { ffi::rlActiveTextureSlot(slot) }
    }
    /// Enable a shader program (by binding the safe handle's GL id).
    #[inline]
    fn rl_enable_shader(&mut self, shader: &crate::core::shaders::Shader) {
        unsafe { ffi::rlEnableShader(shader.id) }
    }
    /// Set the active shader and its uniform locations (from the safe handle).
    #[inline]
    fn rl_set_shader(&mut self, shader: &crate::core::shaders::Shader) {
        unsafe { ffi::rlSetShader(shader.id, shader.locs) }
    }

    /// # Example
    /// ```no_run
    /// use raylib::prelude::*;
    /// fn frame(d: &mut RaylibDrawHandle, tex: &Texture2D) {
    ///     d.rl_set_texture(tex);
    ///     d.rl_draw(DrawMode::Quads, |v| {
    ///         v.color4ub(Color::WHITE);
    ///         v.texcoord2f(0.0, 0.0); v.vertex2f(0.0, 0.0);
    ///         v.texcoord2f(1.0, 0.0); v.vertex2f(64.0, 0.0);
    ///         v.texcoord2f(1.0, 1.0); v.vertex2f(64.0, 64.0);
    ///         v.texcoord2f(0.0, 1.0); v.vertex2f(0.0, 64.0);
    ///     });
    ///     d.rl_disable_texture();
    /// }
    /// ```

cargo build -p raylib
cargo clippy -p raylib -- -D warnings 2>&1 | grep -E "rlgl[/\\\\]|rlgl::" ; echo "(empty = no rlgl clippy hits)"
cargo test -p raylib --doc rlgl

git add raylib/src/rlgl
git commit -m "feat(ws5b): rlgl render-state toggles + bind &Texture2D/&Shader handles

Co-Authored-By: Claude Opus 4.7 <[email protected]>"

//! WS5b Tier-2: rlgl immediate-mode + matrix stack draw into the software
//! framebuffer. Headless. Uses the WS5-prep normalized `render_frame`.
#![cfg(feature = "software_renderer")]
use raylib::prelude::*;

#[test]
fn rlgl_immediate_triangle_renders() {
    raylib::test_harness::with_headless(100, 100, |rl, thread| {
        let img = raylib::test_harness::render_frame(rl, thread, |d| {
            d.clear_background(Color::BLACK);
            // Draw a red triangle in screen space via immediate mode, shifted right
            // by +30px using the matrix stack. raygui/rlsw use a top-left ortho
            // projection in 2D, so screen coords map directly.
            let mut m = d.rl_push_matrix();
            m.rl_translatef(30.0, 0.0, 0.0);
            m.rl_draw(DrawMode::Triangles, |v| {
                v.color4ub(Color::RED);
                v.vertex2f(20.0, 20.0);
                v.vertex2f(60.0, 20.0);
                v.vertex2f(40.0, 70.0);
            });
            // m drops here -> rlPopMatrix
        });

        // Centroid of the (translated) triangle: screen ~ (40+30, 36) = (70, 36).
        // Count red pixels in the triangle's translated bounding box to confirm fill.
        let mut red = 0u32;
        for y in 20..70 {
            for x in 50..90 {
                let p = raylib::test_harness::pixel_at(&img, x, y);
                if p.r > 150 && p.g < 90 && p.b < 90 {
                    red += 1;
                }
            }
        }
        assert!(red > 200, "expected a filled red triangle, got {red} red px");
    });
}

cargo test -p raylib --no-default-features --features software_renderer,SUPPORT_MODULE_RTEXTURES,SUPPORT_MODULE_RSHAPES,SUPPORT_MODULE_RTEXT,SUPPORT_MODULE_RMODELS,SUPPORT_MODULE_RAUDIO,SUPPORT_IMAGE_GENERATION --test render_rlgl -- --test-threads=1 --nocapture

      - name: Tier-2 rlgl render tests
        run: cargo test -p raylib --no-default-features --features software_renderer,SUPPORT_MODULE_RTEXTURES,SUPPORT_MODULE_RSHAPES,SUPPORT_MODULE_RTEXT,SUPPORT_MODULE_RMODELS,SUPPORT_MODULE_RAUDIO,SUPPORT_IMAGE_GENERATION --test render_rlgl -- --test-threads=1

git add raylib/tests/render_rlgl.rs .github/workflows/baseline.yml
git commit -m "test(ws5b): Tier-2 render test for rlgl immediate mode + matrix stack

Co-Authored-By: Claude Opus 4.7 <[email protected]>"

cargo fmt --all -- --check
cargo build -p raylib
cargo build -p raylib --features raygui
cargo clippy -p raylib -- -D warnings 2>&1 | grep -E "rlgl[/\\\\]|rgui[/\\\\]" ; echo "(empty = no rlgl/rgui clippy hits)"
cargo test -p raylib --doc
cargo test -p raylib --no-default-features --features software_renderer,SUPPORT_MODULE_RTEXTURES,SUPPORT_MODULE_RSHAPES,SUPPORT_MODULE_RTEXT,SUPPORT_MODULE_RMODELS,SUPPORT_MODULE_RAUDIO,SUPPORT_IMAGE_GENERATION,raygui --test render_shapes --test render_text --test render_gui --test render_rlgl -- --test-threads=1

git add docs/superpowers/inventory.md docs/superpowers/notes/ws5-complete.md
git commit -m "docs(ws5): WS5 completion note; attribute #234/#179 to rlgl module

Co-Authored-By: Claude Opus 4.7 <[email protected]>"
git push fork 6.0-rc

gh run watch <run-id> -R Dacode45/ms-raylib-rs --exit-status