points: support point texturing

If the GL_COORD_REPLACE flag is set, then instead of the texture
coordinates found on the vertex, we should use a hardcoded (0, 0)
coordinate for the top left corner, and (1, 1) for the bottom right.
We do this by replacing the vertex array with the PointSpritesTexReader
class, whose reader method always returns (0, 0).

We also need to modify a few other places so that the array classes know
what is the primitive being drawn, because this swap must only be
applied when rendering points.

src/arrays.cpp

@@ -208,6 +208,13 @@ struct SphereMapTexReader: public GeneratedTexVertexReader {
     }
 };
 
+struct PointSpritesTexReader: public GeneratedTexVertexReader {
+    using GeneratedTexVertexReader::GeneratedTexVertexReader;
+    void read_tex2f(int index, Tex2f tex) override {
+        tex[0] = tex[1] = 0.0f;
+    }
+};
+
 struct VertexReaderBase: public AbstractVertexReader {
     VertexReaderBase(GxVertexFormat format, VboType vbo, const void *data,
                      int stride):
@@ -558,7 +565,8 @@ static inline VertexReaderBase *get_reader(OgxArrayReader *reader)
     return reinterpret_cast<VertexReaderBase *>(reader);
 }
 
-void _ogx_arrays_setup_draw(bool has_normals, uint8_t num_colors,
+void _ogx_arrays_setup_draw(uint8_t gxmode,
+                            bool has_normals, uint8_t num_colors,
                             uint8_t tex_unit_mask)
 {
     GX_ClearVtxDesc();
@@ -584,6 +592,25 @@ void _ogx_arrays_setup_draw(bool has_normals, uint8_t num_colors,
         for (int i = 0; i < MAX_TEXTURE_UNITS; i++) {
             VertexReaderBase *r = get_reader(&glparamstate.texcoord_array[i]);
             u8 unit_bit = 1 << i;
+
+            if (gxmode == GX_POINTS &&
+                glparamstate.point_sprites_enabled &&
+                glparamstate.point_sprites_coord_replace) {
+                if (tex_unit_mask & unit_bit) {
+                    /* Don't pass the texture coordinates specified by the
+                     * client, but a hardcoded (0, 0). */
+                    GeneratedTexVertexReader *gr =
+                        GeneratedTexVertexReader::create_at
+                        <PointSpritesTexReader>(&glparamstate.texcoord_array[i]);
+                    gr->setup_draw();
+                    gr->set_tex_coord_source(GX_TG_TEX0 + sent_tex_arrays++);
+                    s_tex_unit_mask |= unit_bit;
+                    /* Do not process more units */
+                    i = MAX_TEXTURE_UNITS;
+                }
+                continue;
+            }
+
             if (glparamstate.texture_unit[i].gen_enabled) {
                 /* Some kinds of texture generation cannot be performed by the
                  * GPU, and we have to generate the texture coordinates in

src/arrays.h

@@ -48,7 +48,8 @@ void _ogx_array_reader_init(OgxArrayReader *reader,
                             uint8_t vertex_attribute,
                             const void *data,
                             int num_components, GLenum type, int stride);
-void _ogx_arrays_setup_draw(bool has_normals, uint8_t num_colors,
+void _ogx_arrays_setup_draw(uint8_t gxmode,
+                            bool has_normals, uint8_t num_colors,
                             uint8_t tex_unit_mask);
 /* Get the mask of units having texture coordinates. This is not necessarily
  * the same as glparamstate.cs.texcoord_enabled, because we might have

src/call_lists.c

@@ -229,7 +229,9 @@ static void execute_draw_geometry_list(struct DrawGeometry *dg)
         }
     }
 
-    _ogx_arrays_setup_draw(dg->cs.normal_enabled,
+    DrawMode gxmode = _ogx_draw_mode(dg->mode);
+    _ogx_arrays_setup_draw(gxmode.mode,
+                           dg->cs.normal_enabled,
                            dg->cs.color_enabled ? 2 : 0,
                            dg->cs.texcoord_enabled);
     if (!dg->cs.normal_enabled) {

src/gc_gl.c

@@ -2309,7 +2309,8 @@ static void flat_draw_geometry(void *cb_data)
 {
     OgxDrawData *data = cb_data;
 
-    _ogx_arrays_setup_draw(false, /* no normals */
+    _ogx_arrays_setup_draw(data->gxmode.mode,
+                           false, /* no normals */
                            false, /* no color */
                            false /* no texturing */);
     /* TODO: we could use C++ templates here too, to build more effective
@@ -2348,7 +2349,8 @@ static void flat_draw_elements(void *cb_data)
 {
     OgxDrawElementsData *data = cb_data;
 
-    _ogx_arrays_setup_draw(false, /* no normals */
+    _ogx_arrays_setup_draw(data->gxmode.mode,
+                           false, /* no normals */
                            false, /* no color */
                            false /* no texturing */);
 
@@ -2385,7 +2387,7 @@ void glArrayElement(GLint i)
     }
 }
 
-static bool setup_draw()
+static bool setup_draw(uint8_t gxmode)
 {
     _ogx_efb_set_content_type(OGX_EFB_SCENE);
 
@@ -2398,7 +2400,8 @@ static bool setup_draw()
         else
             color_provide = 1;
     }
-    _ogx_arrays_setup_draw(glparamstate.cs.normal_enabled, color_provide, texen);
+    _ogx_arrays_setup_draw(gxmode,
+                           glparamstate.cs.normal_enabled, color_provide, texen);
 
     /* Note that _ogx_setup_render_stages() uses some information from the
      * vertex arrays computed by _ogx_arrays_setup_draw(), so it must be called
@@ -2429,7 +2432,7 @@ void glDrawArrays(GLenum mode, GLint first, GLsizei count)
 
     _ogx_gpu_resources_push();
 
-    bool should_draw = setup_draw();
+    bool should_draw = setup_draw(gxmode.mode);
     if (should_draw) {
         draw_arrays_general(gxmode, first, count);
         glparamstate.draw_count++;
@@ -2459,7 +2462,7 @@ void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indic
 
     _ogx_gpu_resources_push();
 
-    bool should_draw = setup_draw();
+    bool should_draw = setup_draw(gxmode.mode);
     if (should_draw) {
         draw_elements_general(gxmode, count, type, indices);
         glparamstate.draw_count++;

src/texture_unit.c

@@ -428,6 +428,9 @@ static void setup_texture_stage(const OgxTextureUnit *tu,
                          GX_TEVPREV);
     }
     GX_SetTevOrder(stage, tex_coord, tex_map, channel);
+    bool points_enabled = glparamstate.point_sprites_enabled &&
+        glparamstate.point_sprites_coord_replace;
+    GX_EnableTexOffsets(tex_coord, GX_DISABLE, points_enabled);
     GX_LoadTexObj(&texture_list[tu->glcurtex].texobj, tex_map);
 }