more mesh work on Wii U

Author: TurtleP

include/common/config.hpp

@@ -1,3 +1,12 @@
 #pragma once
 
-#define LOVE_UNUSED(x) (void)sizeof(x)
+namespace love
+{
+    namespace detail
+    {
+        template<typename... T>
+        char unused(T&&...);
+    } // namespace detail
+} // namespace love
+
+#define LOVE_UNUSED(...) (void)sizeof(love::detail::unused(__VA_ARGS__))

include/driver/display/Renderer.tcc

@@ -1,15 +1,10 @@
 #pragma once
 
-#include "common/Singleton.tcc"
-
 #include "modules/graphics/Graphics.tcc"
-#include "modules/graphics/Shader.tcc"
 #include "modules/graphics/renderstate.hpp"
 
 #include "modules/graphics/vertex.hpp"
-
-#include <array>
-#include <vector>
+#include <cstdint>
 
 namespace love
 {
@@ -19,8 +14,33 @@ namespace love
         RendererBase()
         {}
 
+        virtual void init() = 0;
+
+        virtual void close() = 0;
+
+        virtual void clearColor(const Color& color) = 0;
+
+        virtual void clear(double depth, int stencil) = 0;
+
+        virtual void setClearDepth(double depth) = 0;
+
+        virtual void setClearStencil(int stencil) = 0;
+
+        virtual void setStencilState(const StencilState& state) = 0;
+
+        virtual void setViewport(const Rect& viewport) = 0;
+
+        virtual void setScissor(const Rect& scissor) = 0;
+
+        virtual void setCullMode(CullMode mode) = 0;
+
+        virtual void setVertexAttributes(const VertexAttributes& attributes,
+                                         const BufferBindings& buffers) = 0;
+
         virtual void prepareDraw(GraphicsBase* graphics) = 0;
 
+        virtual void present() = 0;
+
         bool isInFrame() const
         {
             return this->inFrame;
@@ -29,17 +49,23 @@ namespace love
       protected:
         struct ContextBase
         {
-            bool dirtyProjection;
-
             CullMode cullMode;
             ColorChannelMask colorMask;
             BlendState blendState;
             StencilState stencilState;
 
             Rect scissor;
             Rect viewport;
+
+            uint8_t currentTextureUnit;
+            bool depthWrites;
         };
 
+        struct State
+        {
+            uint32_t enabledAttribArrays;
+        } renderState;
+
         bool initialized = false;
         bool inFrame     = false;
     };

include/modules/data/misc/ZlibCompressor.hpp

@@ -84,7 +84,8 @@ namespace love
             {
                 inflateEnd(&stream);
 
-                if (error == Z_NEED_DICT || (error == Z_BUF_ERROR && stream.avail_in == 0))
+                if (error == Z_NEED_DICT ||
+                    (error == Z_BUF_ERROR && stream.avail_out > 0 && stream.avail_in == 0))
                     return Z_DATA_ERROR;
 
                 return error;

include/modules/graphics/vertex.hpp

@@ -423,6 +423,8 @@ namespace love
 
     size_t getIndexDataSize(IndexDataType type);
 
+    size_t getVertexAttributeLocation(BuiltinVertexAttribute attribute);
+
     // clang-format off
     STRINGMAP_DECLARE(DataFormats, DataFormat,
         { "float",     DATAFORMAT_FLOAT      },

platform/cafe/CMakeLists.txt

@@ -20,6 +20,7 @@ dkp_track_assets(${PROJECT_NAME}_cafe_content
     FILES
         color.gsh
         texture.gsh
+        video.gsh
 )
 
 dkp_track_assets(${PROJECT_NAME}_cafe_content

platform/cafe/content/shaders/glsl/color_fsh.glsl

@@ -0,0 +1,9 @@
+#version 330
+
+layout (location = 0) in  vec4 VertexColor;
+layout (location = 0) out vec4 VaryingColor;
+
+void main()
+{
+    VaryingColor = VertexColor;
+}

platform/cafe/content/shaders/glsl/texture_fsh.glsl

@@ -0,0 +1,13 @@
+#version 330
+
+layout (location = 0) in vec4 VertexColor;
+layout (location = 1) in vec2 VertexTexCoord;
+
+layout (location = 0) out vec4 VaryingColor;
+
+uniform sampler2D texture0;
+
+void main()
+{
+    VaryingColor = VertexColor * texture(texture0, VertexTexCoord);
+}

platform/cafe/content/shaders/glsl/transform_vsh.glsl

@@ -0,0 +1,23 @@
+#version 330
+
+layout(location = 0) in vec3 VertexPosition;
+layout(location = 1) in vec2 VertexTexCoord;
+layout(location = 2) in vec4 VertexColor;
+
+layout(location = 0) out vec4 VaryingColor;
+layout(location = 1) out vec2 VaryingTexCoord;
+
+layout(std140) uniform Transformation
+{
+    mat4 mdlvMtx;
+    mat4 projMtx;
+} u;
+
+void main()
+{
+    vec4 pos = u.mdlvMtx * vec4(VertexPosition, 1.0);
+    gl_Position = u.projMtx * pos;
+
+    VaryingColor = VertexColor;
+    VaryingTexCoord = VertexTexCoord;
+}

platform/cafe/content/shaders/glsl/video_fsh.glsl

@@ -0,0 +1,32 @@
+#version 330
+
+layout (location = 0) in vec4 VertexColor;
+layout (location = 1) in vec2 VertexTexCoord;
+
+layout (location = 0) out vec4 VaryingColor;
+
+uniform sampler2D video_y;
+uniform sampler2D video_cb;
+uniform sampler2D video_cr;
+
+const vec3 yuv_add = vec3(-0.0627451017, -0.501960814, -0.501960814);
+
+const vec3 yuv_r = vec3(1.164,  0.000,  1.596);
+const vec3 yuv_g = vec3(1.164, -0.391, -0.813);
+const vec3 yuv_b = vec3(1.164,  2.018,  0.000);
+
+void main()
+{
+    vec3 yuv;
+
+    yuv[0] = texture(video_y,  VertexTexCoord).r;
+    yuv[1] = texture(video_cb, VertexTexCoord).r;
+    yuv[2] = texture(video_cr, VertexTexCoord).r;
+
+    yuv += yuv_add;
+
+    VaryingColor[0] = dot(yuv, yuv_r);
+    VaryingColor[1] = dot(yuv, yuv_g);
+    VaryingColor[2] = dot(yuv, yuv_b);
+    VaryingColor[3] = 1.0;
+}

platform/cafe/include/driver/display/Attribute.hpp

@@ -14,40 +14,48 @@ namespace love
       public:
         GX2Attribute();
 
-        GX2Attribute(bool enabled) : stream {}, enabled(enabled)
-        {}
-
         GX2Attribute(uint32_t location, int components, GX2AttribFormat format, uint32_t offset);
 
-        constexpr std::strong_ordering operator<=>(const GX2Attribute& other) const noexcept = default;
-
-        bool operator==(const GX2Attribute& other);
+        bool operator==(const GX2Attribute& other) const;
 
         operator GX2AttribStream()
         {
             return this->stream;
         }
 
-        bool isEnabled() const
+        GX2Attribute& setLocation(uint32_t location)
         {
-            return this->enabled;
+            this->stream.location = location;
+            return *this;
         }
 
-        void update(uint32_t location, int components, GX2AttribFormat format, uint32_t offset);
+        GX2Attribute& setFormat(GX2AttribFormat format)
+        {
+            this->stream.format = format;
+            return *this;
+        }
 
-        void setBuffer(uint32_t buffer);
+        GX2Attribute& setComponents(uint32_t components);
 
-        void setEnabled(bool enabled);
+        GX2Attribute& setOffset(uint32_t offset)
+        {
+            this->stream.offset = offset;
+            return *this;
+        }
 
-        void setDivisor(uint32_t divisor);
+        GX2Attribute& setBuffer(uint32_t buffer)
+        {
+            this->stream.buffer = buffer;
+            return *this;
+        }
 
-        GX2AttribStream getStream() const
+        GX2Attribute& setDivisor(uint32_t divisor)
         {
-            return this->stream;
+            this->stream.aluDivisor = divisor;
+            return *this;
         }
 
       private:
         GX2AttribStream stream;
-        bool enabled;
     };
 } // namespace love