Support textured triangles

examples/PoolBox/application/src/main.cpp

@@ -39,17 +39,19 @@ static void load_assets() {
 }
 
 void main() {
-    const JabyEngine::GPU::POLY_F3 triangle(
+    const JabyEngine::GPU::POLY_F3  triangle({{0, 0}, {64, 64}, {0, 64}}, JabyEngine::GPU::Color24(0x0, 0xFF, 0xFF));
-        JabyEngine::GPU::Color24(0x0, 0xFF, 0xFF),
+    const JabyEngine::GPU::POLY_FT3 triangle2(
-        {
+        {{0, 0}, {64, 0}, {64, 64}}, {{0, 0}, {64, 0}, {64, 64}}, 
-            {0, 0}, {320*2, 127}, {0, 255}
+        JabyEngine::GPU::TPage(320, 0, JabyEngine::GPU::SemiTransparency::B_Half_add_F_Half, JabyEngine::GPU::TexturePageColor::$4bit),        
-        }
+        JabyEngine::GPU::PageClut(320, 256),
-    );
+        JabyEngine::GPU::Color24(0xFF, 0xFF, 0xFF));
-    printf("Hello PoolBox!\n");
+
     load_assets();
 
     while(true) {
         JabyEngine::GPU::render(triangle);
+        JabyEngine::GPU::render(triangle2);
+
         JabyEngine::GPU::swap_buffers_vsync(2);
     }
 }

include/PSX/GPU/gpu_primitives.hpp

@@ -1,13 +1,14 @@
 #ifndef __JABYENGINE_GPU_PRIMITIVES_HPP__
 #define __JABYENGINE_GPU_PRIMITIVES_HPP__
 #include "gpu_types.hpp"
+#include <PSX/System/IOPorts/gpu_io.hpp>
 
 namespace JabyEngine {
     namespace GPU {
         namespace internal {
             struct Code {
-                static constexpr uint8_t CmdValue       = 0b001;
+                static constexpr uint8_t CmdValue      = 0b001;
-                static constexpr auto     BitCorrection = 24;
+                static constexpr auto    BitCorrection = 24;
 
                 static constexpr auto CmdID           = BitRange::from_to(29 - BitCorrection, 31 - BitCorrection);
                 static constexpr auto GouraudShading  = Bit(28 - BitCorrection);
@@ -24,6 +25,8 @@ namespace JabyEngine {
                 uint8_t value = bit::value::set_normalized(0u, CmdID.with(CmdValue));
 
                 constexpr Code() = default;
+                constexpr Code(const Code& code) : value(code.value) {
+                }
 
                 constexpr Code& set(Bit bit) {
                     this->value = bit::set(this->value, bit);
@@ -36,8 +39,11 @@ namespace JabyEngine {
                 }
             };
 
-            struct IsPrimitive {
+            // Concept for now
-                static constexpr bool is_primitive = true;
+            template<typename T>
+            struct Hooked {
+                uint32_t hook;
+                T        primitive;
             };
 
             template<typename T>
@@ -63,27 +69,82 @@ namespace JabyEngine {
                 }
             };
 
-            // Concept for now
+            struct IsPrimitive {
-            template<typename T>
+                static constexpr bool is_primitive = true;
-            struct Hooked {
+
-                uint32_t hook;
+                typedef JabyEngine::GPU::internal::Code Code;
-                T        primitive;
             };
         }
 
-        struct POLY_F3 : public internal::IsPrimitive, public internal::CodeInterface<POLY_F3> {
+        // Reexport for easier use
-            static constexpr auto IdentityCode = internal::Code().set(internal::Code::FlatShading).set(internal::Code::TriVertics).set(internal::Code::Untextured).set(internal::Code::NonTransparent).set(internal::Code::NoBlendTexture);
+        typedef JabyEngine::GPU_IO::SemiTransparency SemiTransparency; 
-            
+        typedef JabyEngine::GPU_IO::TexturePageColor TexturePageColor;
-            Color24        color;
-            internal::Code code = IdentityCode;
-            PositionI16    vertex[3];
 
-            constexpr POLY_F3() = default;
+        struct PageClut {
-            constexpr POLY_F3(Color24 color, const PositionI16 (&verticies)[3]) : color(color), code(IdentityCode), vertex{verticies[0], verticies[1], verticies[2]} {
+            uint16_t value = 0;
+            
+            constexpr PageClut() = default;
+            constexpr PageClut(uint16_t x, uint16_t y) : value((y <<6 ) | ((x >> 4) & 0x3f)) {
             }
         };
 
-        static_assert(sizeof(POLY_F3) == 16);
+
+        struct TPage {
+            static constexpr auto TexturePageX     = BitRange::from_to(0, 3);
+            static constexpr auto TexturePageY     = BitRange::from_to(4, 4);
+            static constexpr auto SemiTransparency = BitRange::from_to(5, 6);
+            static constexpr auto TextureClut      = BitRange::from_to(7, 8);
+
+            uint16_t value = 0;
+
+            constexpr TPage() = default;
+            constexpr TPage(uint16_t x, uint16_t y, ::JabyEngine::GPU::SemiTransparency transparency, TexturePageColor clut_color) : value(TexturePageX.as_value(x >> 6) | TexturePageY.as_value(y >> 8) | SemiTransparency.as_value(static_cast<uint16_t>(transparency)) | TextureClut.as_value(static_cast<uint16_t>(clut_color))) {
+            }
+        };
+
+        /*
+            1
+           / \
+          3 - 2
+        */
+        struct POLY_F3 : public internal::IsPrimitive, public internal::CodeInterface<POLY_F3> {
+            static constexpr auto IdentityCode = Code().set(Code::FlatShading).set(Code::TriVertics).set(Code::Untextured).set(Code::NonTransparent).set(Code::NoBlendTexture);
+            
+            Color24 color;
+            Code    code = IdentityCode;
+            Vertex  vertex0;
+            Vertex  vertex1;
+            Vertex  vertex2;
+
+            constexpr POLY_F3() = default;
+            constexpr POLY_F3(const PositionI16 (&verticies)[3], Color24 color) : color(color), code(IdentityCode), vertex0(verticies[0]), vertex1(verticies[1]), vertex2(verticies[2]) {
+            }
+        };
+
+        struct POLY_FT3 : public internal::IsPrimitive, public internal::CodeInterface<POLY_FT3> {
+            static constexpr auto IdentityCode = Code(POLY_F3::IdentityCode).set(Code::Textured);
+
+            Color24      color;
+            Code         code = IdentityCode;
+            Vertex       vertex0;
+            PagePosition page0;
+            PageClut     page_clut;
+            Vertex       vertex1;
+            PagePosition page1;
+            TPage        tpage;
+            Vertex       vertex2;
+            PagePosition page2;
+            uint16_t     padded;
+
+            constexpr POLY_FT3() = default;
+            constexpr POLY_FT3(const PositionI16 (&verticies)[3], const PagePosition (&page_pos)[3], TPage tpage, PageClut clut, Color24 color) 
+                : color(color), code(IdentityCode), vertex0(verticies[0]), page0(page_pos[0]), page_clut(clut),
+                  vertex1(verticies[1]), page1(page_pos[1]), tpage(tpage), vertex2(verticies[2]), page2(page_pos[2]) {
+                  }
+        };
+
+        static_assert(sizeof(POLY_F3)  == 16);
+        static_assert(sizeof(POLY_FT3) == 28);
     }
 }
 

include/PSX/GPU/gpu_types.hpp

@@ -105,6 +105,16 @@ namespace JabyEngine {
             }
         };
 
+        // Type used for primitives
+        struct PagePosition {
+            uint8_t u = 0;
+            uint8_t v = 0;
+
+            constexpr PagePosition() = default;
+            constexpr PagePosition(uint8_t u, uint8_t v) : u(u), v(v) {
+            }
+        };
+
         typedef Position<int16_t>  PositionI16;
         typedef Position<uint16_t> PositionU16;
 
@@ -113,6 +123,9 @@ namespace JabyEngine {
 
         typedef Area<int16_t>  AreaI16;
         typedef Area<uint16_t> AreaU16;
+
+        // Type used for primitives
+        typedef PositionI16 Vertex;
     }
 }
 #endif //!__JABYENGINE_GPU_TYPES_HPP__