--- /dev/null
+/*
+ * Copyright (C) 2011 Gilead Kutnick "Exophase" <exophase@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include <math.h>
+
+#include "common.h"
+
+typedef s32 fixed_type;
+
+#define EDGE_STEP_BITS 32
+#define FIXED_BITS 12
+
+#define fixed_center(value) \
+ ((((fixed_type)value) << FIXED_BITS) + (1 << (FIXED_BITS - 1))) \
+
+#define int_to_fixed(value) \
+ (((fixed_type)value) << FIXED_BITS) \
+
+#define fixed_to_int(value) \
+ ((value) >> FIXED_BITS) \
+
+#define fixed_mul(_a, _b) \
+ (((s64)(_a) * (_b)) >> FIXED_BITS) \
+
+#define fixed_to_double(value) \
+ ((value) / (double)(1 << FIXED_BITS)) \
+
+#define double_to_fixed(value) \
+ (fixed_type)(((value) * (double)(1 << FIXED_BITS))) \
+
+typedef struct
+{
+ fixed_type current_value;
+ fixed_type step_dx;
+ fixed_type step_dy;
+ fixed_type gradient_area_x;
+ fixed_type gradient_area_y;
+} interpolant_struct;
+
+typedef struct
+{
+ s32 base_x;
+
+ s64 left_x;
+ s64 left_dx_dy;
+
+ s64 right_x;
+ s64 right_dx_dy;
+
+ u32 triangle_area;
+ u32 triangle_winding;
+
+ interpolant_struct u;
+ interpolant_struct v;
+ interpolant_struct r;
+ interpolant_struct g;
+ interpolant_struct b;
+} _span_struct;
+
+
+u32 span_pixels = 0;
+u32 span_pixel_blocks = 0;
+u32 spans = 0;
+u32 triangles = 0;
+
+u32 texels_4bpp = 0;
+u32 texels_8bpp = 0;
+u32 texels_16bpp = 0;
+u32 untextured_pixels = 0;
+u32 blend_pixels = 0;
+u32 transparent_pixels = 0;
+
+u32 state_changes = 0;
+u32 render_buffer_flushes = 0;
+u32 trivial_rejects = 0;
+
+void flush_render_block_buffer(psx_gpu_struct *psx_gpu)
+{
+
+}
+
+
+u32 fixed_reciprocal(u32 denominator, u32 *_shift)
+{
+ u32 shift = __builtin_clz(denominator);
+ u32 denominator_normalized = denominator << shift;
+
+ // Implement with a DP divide
+ u32 reciprocal =
+ (double)((1ULL << 62) + (denominator_normalized - 1)) /
+ (double)denominator_normalized;
+
+ *_shift = 62 - shift;
+ return reciprocal;
+}
+
+fixed_type fixed_reciprocal_multiply(s32 numerator, u32 reciprocal,
+ u32 reciprocal_sign, u32 shift)
+{
+ u32 numerator_sign = (u32)numerator >> 31;
+ u32 flip_sign = numerator_sign ^ reciprocal_sign;
+ u32 flip_sign_mask = ~(flip_sign - 1);
+ fixed_type value;
+
+ numerator = abs(numerator);
+
+ value = ((u64)numerator * reciprocal) >> shift;
+
+ value ^= flip_sign_mask;
+ value -= flip_sign_mask;
+
+ return value;
+}
+
+s32 triangle_signed_area_x2(s32 x0, s32 y0, s32 x1, s32 y1, s32 x2, s32 y2)
+{
+ return ((x1 - x0) * (y2 - y1)) - ((x2 - x1) * (y1 - y0));
+}
+
+u32 fetch_texel_4bpp(psx_gpu_struct *psx_gpu, u32 u, u32 v)
+{
+ u8 *texture_ptr_8bpp = psx_gpu->texture_page_ptr;
+ u32 texel = texture_ptr_8bpp[(v * 2048) + (u / 2)];
+
+ if(u & 1)
+ texel >>= 4;
+ else
+ texel &= 0xF;
+
+ texels_4bpp++;
+
+ return psx_gpu->clut_ptr[texel];
+}
+
+u32 fetch_texel_8bpp(psx_gpu_struct *psx_gpu, u32 u, u32 v)
+{
+ u8 *texture_ptr_8bpp = psx_gpu->texture_page_ptr;
+ u32 texel = texture_ptr_8bpp[(v * 2048) + u];
+
+ texels_8bpp++;
+
+ return psx_gpu->clut_ptr[texel];
+}
+
+u32 fetch_texel_16bpp(psx_gpu_struct *psx_gpu, u32 u, u32 v)
+{
+ u16 *texture_ptr_16bpp = psx_gpu->texture_page_ptr;
+
+ texels_16bpp++;
+
+ return texture_ptr_16bpp[(v * 1024) + u];
+}
+
+u32 fetch_texel(psx_gpu_struct *psx_gpu, u32 u, u32 v)
+{
+ u &= psx_gpu->texture_mask_width;
+ v &= psx_gpu->texture_mask_height;
+
+ switch(psx_gpu->texture_mode)
+ {
+ case TEXTURE_MODE_4BPP:
+ return fetch_texel_4bpp(psx_gpu, u, v);
+
+ case TEXTURE_MODE_8BPP:
+ return fetch_texel_8bpp(psx_gpu, u, v);
+
+ case TEXTURE_MODE_16BPP:
+ return fetch_texel_16bpp(psx_gpu, u, v);
+ }
+
+ return 0;
+}
+
+void draw_pixel(psx_gpu_struct *psx_gpu, s32 r, s32 g, s32 b, u32 texel,
+ u32 x, u32 y, u32 flags)
+{
+ u32 pixel;
+
+ if(r > 31)
+ r = 31;
+
+ if(g > 31)
+ g = 31;
+
+ if(b > 31)
+ b = 31;
+
+ if(flags & RENDER_FLAGS_BLEND)
+ {
+ if(((flags & RENDER_FLAGS_TEXTURE_MAP) == 0) || (texel & 0x8000))
+ {
+ s32 fb_pixel = psx_gpu->vram[(y * 1024) + x];
+ s32 fb_r = fb_pixel & 0x1F;
+ s32 fb_g = (fb_pixel >> 5) & 0x1F;
+ s32 fb_b = (fb_pixel >> 10) & 0x1F;
+
+ blend_pixels++;
+
+ switch(psx_gpu->blend_mode)
+ {
+ case BLEND_MODE_AVERAGE:
+ r = (r + fb_r) / 2;
+ g = (g + fb_g) / 2;
+ b = (b + fb_b) / 2;
+ break;
+
+ case BLEND_MODE_ADD:
+ r += fb_r;
+ g += fb_g;
+ b += fb_b;
+
+ if(r > 31)
+ r = 31;
+
+ if(g > 31)
+ g = 31;
+
+ if(b > 31)
+ b = 31;
+
+ break;
+
+ case BLEND_MODE_SUBTRACT:
+ r = fb_r - r;
+ g = fb_g - g;
+ b = fb_b - b;
+
+ if(r < 0)
+ r = 0;
+
+ if(g < 0)
+ g = 0;
+
+ if(b < 0)
+ b = 0;
+
+ break;
+
+ case BLEND_MODE_ADD_FOURTH:
+ r = fb_r + (r / 4);
+ g = fb_g + (g / 4);
+ b = fb_b + (b / 4);
+
+ if(r > 31)
+ r = 31;
+
+ if(g > 31)
+ g = 31;
+
+ if(b > 31)
+ b = 31;
+
+ break;
+ }
+ }
+ }
+
+ pixel = r | (g << 5) | (b << 10);
+
+ if(psx_gpu->mask_apply || (texel & 0x8000))
+ pixel |= 0x8000;
+
+ psx_gpu->vram[(y * 1024) + x] = pixel;
+}
+
+s32 dither_table[4][4] =
+{
+ { -4, 0, -3, 1 },
+ { 2, -2, 3, -1 },
+ { -3, 1, -4, 0 },
+ { 3, -1, 2, -2 },
+};
+
+void render_span(psx_gpu_struct *psx_gpu, _span_struct *span, s32 y,
+ u32 flags)
+{
+ s32 left_x = span->left_x >> EDGE_STEP_BITS;
+ s32 right_x = span->right_x >> EDGE_STEP_BITS;
+ s32 current_x = left_x;
+ s32 delta_x;
+
+ fixed_type current_u = span->u.current_value;
+ fixed_type current_v = span->v.current_value;
+ fixed_type current_r = span->r.current_value;
+ fixed_type current_g = span->g.current_value;
+ fixed_type current_b = span->b.current_value;
+
+ if(y < psx_gpu->viewport_start_y)
+ return;
+
+ if(y > psx_gpu->viewport_end_y)
+ return;
+
+ if(right_x < psx_gpu->viewport_start_x)
+ return;
+
+ if(current_x > psx_gpu->viewport_end_x)
+ return;
+
+ spans++;
+
+ if(current_x < psx_gpu->viewport_start_x)
+ current_x = psx_gpu->viewport_start_x;
+
+ if(right_x > psx_gpu->viewport_end_x + 1)
+ right_x = psx_gpu->viewport_end_x + 1;
+
+ delta_x = current_x - span->base_x;
+
+ current_u += delta_x * span->u.step_dx;
+ current_v += delta_x * span->v.step_dx;
+ current_r += delta_x * span->r.step_dx;
+ current_g += delta_x * span->g.step_dx;
+ current_b += delta_x * span->b.step_dx;
+
+ span_pixels += right_x - current_x;
+ span_pixel_blocks += ((right_x / 8) - (current_x / 8)) + 1;
+
+ while(current_x < right_x)
+ {
+ s32 color_r, color_g, color_b;
+ u32 texel = 0;
+
+ if(psx_gpu->mask_evaluate &&
+ (psx_gpu->vram[(y * 1024) + current_x] & 0x8000))
+ {
+ goto skip_pixel;
+ }
+
+ if(flags & RENDER_FLAGS_SHADE)
+ {
+ color_r = fixed_to_int(current_r);
+ color_g = fixed_to_int(current_g);
+ color_b = fixed_to_int(current_b);
+ }
+ else
+ {
+ color_r = psx_gpu->primitive_color & 0xFF;
+ color_g = (psx_gpu->primitive_color >> 8) & 0xFF;
+ color_b = (psx_gpu->primitive_color >> 16) & 0xFF;
+ }
+
+ if(flags & RENDER_FLAGS_TEXTURE_MAP)
+ {
+ u32 texel_r, texel_g, texel_b;
+ u32 u = fixed_to_int(current_u);
+ u32 v = fixed_to_int(current_v);
+
+ texel = fetch_texel(psx_gpu, u, v);
+
+ if(texel == 0)
+ {
+ transparent_pixels++;
+ goto skip_pixel;
+ }
+
+ texel_r = texel & 0x1F;
+ texel_g = (texel >> 5) & 0x1F;
+ texel_b = (texel >> 10) & 0x1F;
+
+ if((flags & RENDER_FLAGS_MODULATE_TEXELS) == 0)
+ {
+ color_r *= texel_r;
+ color_g *= texel_g;
+ color_b *= texel_b;
+ }
+ else
+ {
+ color_r = texel_r << 7;
+ color_g = texel_g << 7;
+ color_b = texel_b << 7;
+ }
+
+ color_r >>= 4;
+ color_g >>= 4;
+ color_b >>= 4;
+ }
+ else
+ {
+ untextured_pixels++;
+ }
+
+ if(psx_gpu->dither_mode && ((flags & RENDER_FLAGS_SHADE) ||
+ ((flags & RENDER_FLAGS_TEXTURE_MAP) &&
+ ((flags & RENDER_FLAGS_MODULATE_TEXELS) == 0))))
+ {
+ s32 dither_offset = dither_table[y % 4][current_x % 4];
+ color_r += dither_offset;
+ color_g += dither_offset;
+ color_b += dither_offset;
+
+ if(color_r < 0)
+ color_r = 0;
+
+ if(color_g < 0)
+ color_g = 0;
+
+ if(color_b < 0)
+ color_b = 0;
+ }
+
+ color_r >>= 3;
+ color_g >>= 3;
+ color_b >>= 3;
+
+ draw_pixel(psx_gpu, color_r, color_g, color_b, texel, current_x, y, flags);
+
+ skip_pixel:
+
+ current_u += span->u.step_dx;
+ current_v += span->v.step_dx;
+ current_r += span->r.step_dx;
+ current_g += span->g.step_dx;
+ current_b += span->b.step_dx;
+
+ current_x++;
+ }
+}
+
+void increment_span(_span_struct *span)
+{
+ span->left_x += span->left_dx_dy;
+ span->right_x += span->right_dx_dy;
+
+ span->u.current_value += span->u.step_dy;
+ span->v.current_value += span->v.step_dy;
+ span->r.current_value += span->r.step_dy;
+ span->g.current_value += span->g.step_dy;
+ span->b.current_value += span->b.step_dy;
+}
+
+void decrement_span(_span_struct *span)
+{
+ span->left_x += span->left_dx_dy;
+ span->right_x += span->right_dx_dy;
+
+ span->u.current_value -= span->u.step_dy;
+ span->v.current_value -= span->v.step_dy;
+ span->r.current_value -= span->r.step_dy;
+ span->g.current_value -= span->g.step_dy;
+ span->b.current_value -= span->b.step_dy;
+}
+
+
+#define compute_gradient_area_x(interpolant) \
+{ \
+ span.interpolant.gradient_area_x = \
+ triangle_signed_area_x2(a->interpolant, a->y, b->interpolant, b->y, \
+ c->interpolant, c->y); \
+} \
+
+#define compute_gradient_area_y(interpolant) \
+{ \
+ span.interpolant.gradient_area_y = \
+ triangle_signed_area_x2(a->x, a->interpolant, b->x, b->interpolant, \
+ c->x, c->interpolant); \
+} \
+
+#define compute_all_gradient_areas() \
+ compute_gradient_area_x(u); \
+ compute_gradient_area_x(v); \
+ compute_gradient_area_x(r); \
+ compute_gradient_area_x(g); \
+ compute_gradient_area_x(b); \
+ compute_gradient_area_y(u); \
+ compute_gradient_area_y(v); \
+ compute_gradient_area_y(r); \
+ compute_gradient_area_y(g); \
+ compute_gradient_area_y(b) \
+
+#define set_interpolant_base(interpolant, base_vertex) \
+ span->interpolant.step_dx = \
+ fixed_reciprocal_multiply(span->interpolant.gradient_area_x, reciprocal, \
+ span->triangle_winding, shift); \
+ span->interpolant.step_dy = \
+ fixed_reciprocal_multiply(span->interpolant.gradient_area_y, reciprocal, \
+ span->triangle_winding, shift); \
+ span->interpolant.current_value = fixed_center(base_vertex->interpolant) \
+
+#define set_interpolant_bases(base_vertex) \
+{ \
+ u32 shift; \
+ u32 reciprocal = fixed_reciprocal(span->triangle_area, &shift); \
+ shift -= FIXED_BITS; \
+ set_interpolant_base(u, base_vertex); \
+ set_interpolant_base(v, base_vertex); \
+ set_interpolant_base(r, base_vertex); \
+ set_interpolant_base(g, base_vertex); \
+ set_interpolant_base(b, base_vertex); \
+ span->base_x = span->left_x >> EDGE_STEP_BITS; \
+} \
+
+#define compute_edge_delta(edge, start, end, height) \
+{ \
+ s32 x_start = start->x; \
+ s32 x_end = end->x; \
+ s32 width = x_end - x_start; \
+ \
+ s32 shift = __builtin_clz(height); \
+ u32 height_normalized = height << shift; \
+ u32 height_reciprocal = ((1ULL << 50) + (height_normalized - 1)) / \
+ height_normalized; \
+ \
+ shift -= (50 - EDGE_STEP_BITS); \
+ \
+ span->edge##_x = \
+ ((((s64)x_start * height) + (height - 1)) * height_reciprocal) << shift; \
+ span->edge##_dx_dy = ((s64)width * height_reciprocal) << shift; \
+} \
+
+
+#define render_spans_up(height) \
+ do \
+ { \
+ decrement_span(span); \
+ render_span(psx_gpu, span, current_y, flags); \
+ current_y--; \
+ height--; \
+ } while(height) \
+
+#define render_spans_down(height) \
+ do \
+ { \
+ render_span(psx_gpu, span, current_y, flags); \
+ increment_span(span); \
+ current_y++; \
+ height--; \
+ } while(height) \
+
+#define render_spans_up_up(minor, major) \
+ s32 current_y = bottom->y - 1; \
+ s32 height_minor_a = bottom->y - middle->y; \
+ s32 height_minor_b = middle->y - top->y; \
+ s32 height_major = height_minor_a + height_minor_b; \
+ \
+ compute_edge_delta(major, bottom, top, height_major); \
+ compute_edge_delta(minor, bottom, middle, height_minor_a); \
+ set_interpolant_bases(bottom); \
+ \
+ render_spans_up(height_minor_a); \
+ \
+ compute_edge_delta(minor, middle, top, height_minor_b); \
+ render_spans_up(height_minor_b) \
+
+void render_spans_up_left(psx_gpu_struct *psx_gpu, _span_struct *span,
+ vertex_struct *bottom, vertex_struct *middle, vertex_struct *top, u32 flags)
+{
+ render_spans_up_up(left, right);
+}
+
+void render_spans_up_right(psx_gpu_struct *psx_gpu, _span_struct *span,
+ vertex_struct *bottom, vertex_struct *middle, vertex_struct *top, u32 flags)
+{
+ render_spans_up_up(right, left);
+}
+
+#define render_spans_down_down(minor, major) \
+ s32 current_y = top->y; \
+ s32 height_minor_a = middle->y - top->y; \
+ s32 height_minor_b = bottom->y - middle->y; \
+ s32 height_major = height_minor_a + height_minor_b; \
+ \
+ compute_edge_delta(minor, top, middle, height_minor_a); \
+ compute_edge_delta(major, top, bottom, height_major); \
+ set_interpolant_bases(top); \
+ \
+ render_spans_down(height_minor_a); \
+ \
+ compute_edge_delta(minor, middle, bottom, height_minor_b); \
+ render_spans_down(height_minor_b) \
+
+void render_spans_down_left(psx_gpu_struct *psx_gpu, _span_struct *span,
+ vertex_struct *top, vertex_struct *middle, vertex_struct *bottom, u32 flags)
+{
+ render_spans_down_down(left, right);
+}
+
+void render_spans_down_right(psx_gpu_struct *psx_gpu, _span_struct *span,
+ vertex_struct *top, vertex_struct *middle, vertex_struct *bottom, u32 flags)
+{
+ render_spans_down_down(right, left);
+}
+
+#define render_spans_up_flat(bottom_left, bottom_right, top_left, top_right) \
+ s32 current_y = bottom_left->y - 1; \
+ s32 height = bottom_left->y - top_left->y; \
+ \
+ compute_edge_delta(left, bottom_left, top_left, height); \
+ compute_edge_delta(right, bottom_right, top_right, height); \
+ set_interpolant_bases(bottom_left); \
+ render_spans_up(height) \
+
+void render_spans_up_a(psx_gpu_struct *psx_gpu, _span_struct *span,
+ vertex_struct *bottom_left, vertex_struct *bottom_right, vertex_struct *top,
+ u32 flags)
+{
+ render_spans_up_flat(bottom_left, bottom_right, top, top);
+}
+
+void render_spans_up_b(psx_gpu_struct *psx_gpu, _span_struct *span,
+ vertex_struct *bottom, vertex_struct *top_left, vertex_struct *top_right,
+ u32 flags)
+{
+ render_spans_up_flat(bottom, bottom, top_left, top_right);
+}
+
+#define render_spans_down_flat(top_left, top_right, bottom_left, bottom_right) \
+ s32 current_y = top_left->y; \
+ s32 height = bottom_left->y - top_left->y; \
+ \
+ compute_edge_delta(left, top_left, bottom_left, height); \
+ compute_edge_delta(right, top_right, bottom_right, height); \
+ set_interpolant_bases(top_left); \
+ render_spans_down(height) \
+
+void render_spans_down_a(psx_gpu_struct *psx_gpu, _span_struct *span,
+ vertex_struct *top_left, vertex_struct *top_right, vertex_struct *bottom,
+ u32 flags)
+{
+ render_spans_down_flat(top_left, top_right, bottom, bottom);
+}
+
+void render_spans_down_b(psx_gpu_struct *psx_gpu, _span_struct *span,
+ vertex_struct *top, vertex_struct *bottom_left, vertex_struct *bottom_right,
+ u32 flags)
+{
+ render_spans_down_flat(top, top, bottom_left, bottom_right);
+}
+
+void render_spans_up_down(psx_gpu_struct *psx_gpu, _span_struct *span,
+ vertex_struct *middle, vertex_struct *top, vertex_struct *bottom, u32 flags)
+{
+ s32 middle_y = middle->y;
+ s32 current_y = middle_y - 1;
+ s32 height_minor_a = middle->y - top->y;
+ s32 height_minor_b = bottom->y - middle->y;
+ s32 height_major = height_minor_a + height_minor_b;
+
+ u64 right_x_mid;
+
+ compute_edge_delta(left, middle, top, height_minor_a);
+ compute_edge_delta(right, bottom, top, height_major);
+ set_interpolant_bases(middle);
+
+ right_x_mid = span->right_x + (span->right_dx_dy * height_minor_b);
+ span->right_x = right_x_mid;
+
+ render_spans_up(height_minor_a);
+
+ compute_edge_delta(left, middle, bottom, height_minor_b);
+ set_interpolant_bases(middle);
+
+ span->right_dx_dy *= -1;
+ span->right_x = right_x_mid;
+ current_y = middle_y;
+
+ render_spans_down(height_minor_b);
+}
+
+#define vertex_swap(_a, _b) \
+{ \
+ vertex_struct *temp_vertex = _a; \
+ _a = _b; \
+ _b = temp_vertex; \
+ triangle_winding ^= 1; \
+} \
+
+
+#define triangle_y_direction_up 1
+#define triangle_y_direction_flat 2
+#define triangle_y_direction_down 0
+
+#define triangle_winding_positive 0
+#define triangle_winding_negative 1
+
+#define triangle_set_direction(direction_variable, value) \
+ u32 direction_variable = (u32)(value) >> 31; \
+ if(value == 0) \
+ direction_variable = 2 \
+
+#define triangle_case(direction_a, direction_b, direction_c, winding) \
+ case (triangle_y_direction_##direction_a | \
+ (triangle_y_direction_##direction_b << 2) | \
+ (triangle_y_direction_##direction_c << 4) | \
+ (triangle_winding_##winding << 6)) \
+
+
+void render_triangle(psx_gpu_struct *psx_gpu, vertex_struct *vertexes,
+ u32 flags)
+{
+ s32 triangle_area;
+ u32 triangle_winding = 0;
+ _span_struct span;
+
+ vertex_struct *a = &(vertexes[0]);
+ vertex_struct *b = &(vertexes[1]);
+ vertex_struct *c = &(vertexes[2]);
+
+ triangle_area = triangle_signed_area_x2(a->x, a->y, b->x, b->y, c->x, c->y);
+
+ triangles++;
+
+ if(triangle_area == 0)
+ return;
+
+ if(b->y < a->y)
+ vertex_swap(a, b);
+
+ if(c->y < b->y)
+ {
+ vertex_swap(b, c);
+
+ if(b->y < a->y)
+ vertex_swap(a, b);
+ }
+
+ if((c->y - a->y) >= 512)
+ return;
+
+ if(triangle_area < 0)
+ {
+ triangle_area = -triangle_area;
+ triangle_winding ^= 1;
+ vertex_swap(a, c);
+ }
+
+ if(b->x < a->x)
+ vertex_swap(a, b);
+
+ if(c->x < b->x)
+ {
+ vertex_swap(b, c);
+
+ if(b->x < a->x)
+ vertex_swap(a, b);
+ }
+
+ if((c->x - a->x) >= 1024)
+ return;
+
+ s32 y_delta_a = b->y - a->y;
+ s32 y_delta_b = c->y - b->y;
+ s32 y_delta_c = c->y - a->y;
+
+ triangle_set_direction(y_direction_a, y_delta_a);
+ triangle_set_direction(y_direction_b, y_delta_b);
+ triangle_set_direction(y_direction_c, y_delta_c);
+
+ compute_all_gradient_areas();
+ span.triangle_area = triangle_area;
+ span.triangle_winding = triangle_winding;
+
+ switch(y_direction_a | (y_direction_b << 2) | (y_direction_c << 4) |
+ (triangle_winding << 6))
+ {
+ triangle_case(up, up, up, negative):
+ triangle_case(up, up, flat, negative):
+ triangle_case(up, up, down, negative):
+ render_spans_up_right(psx_gpu, &span, a, b, c, flags);
+ break;
+
+ triangle_case(flat, up, up, negative):
+ triangle_case(flat, up, flat, negative):
+ triangle_case(flat, up, down, negative):
+ render_spans_up_a(psx_gpu, &span, a, b, c, flags);
+ break;
+
+ triangle_case(down, up, up, negative):
+ render_spans_up_down(psx_gpu, &span, a, c, b, flags);
+ break;
+
+ triangle_case(down, up, flat, negative):
+ render_spans_down_a(psx_gpu, &span, a, c, b, flags);
+ break;
+
+ triangle_case(down, up, down, negative):
+ render_spans_down_right(psx_gpu, &span, a, c, b, flags);
+ break;
+
+ triangle_case(down, flat, up, negative):
+ triangle_case(down, flat, flat, negative):
+ triangle_case(down, flat, down, negative):
+ render_spans_down_b(psx_gpu, &span, a, b, c, flags);
+ break;
+
+ triangle_case(down, down, up, negative):
+ triangle_case(down, down, flat, negative):
+ triangle_case(down, down, down, negative):
+ render_spans_down_left(psx_gpu, &span, a, b, c, flags);
+ break;
+
+ triangle_case(up, up, up, positive):
+ triangle_case(up, up, flat, positive):
+ triangle_case(up, up, down, positive):
+ render_spans_up_left(psx_gpu, &span, a, b, c, flags);
+ break;
+
+ triangle_case(up, flat, up, positive):
+ triangle_case(up, flat, flat, positive):
+ triangle_case(up, flat, down, positive):
+ render_spans_up_b(psx_gpu, &span, a, b, c, flags);
+ break;
+
+ triangle_case(up, down, up, positive):
+ render_spans_up_right(psx_gpu, &span, a, c, b, flags);
+ break;
+
+ triangle_case(up, down, flat, positive):
+ render_spans_up_a(psx_gpu, &span, a, c, b, flags);
+ break;
+
+ triangle_case(up, down, down, positive):
+ render_spans_up_down(psx_gpu, &span, a, b, c, flags);
+ break;
+
+ triangle_case(flat, down, up, positive):
+ triangle_case(flat, down, flat, positive):
+ triangle_case(flat, down, down, positive):
+ render_spans_down_a(psx_gpu, &span, a, b, c, flags);
+ break;
+
+ triangle_case(down, down, up, positive):
+ triangle_case(down, down, flat, positive):
+ triangle_case(down, down, down, positive):
+ render_spans_down_right(psx_gpu, &span, a, b, c, flags);
+ break;
+ }
+
+}
+
+
+void render_sprite(psx_gpu_struct *psx_gpu, s32 x, s32 y, u32 u, u32 v,
+ s32 width, s32 height, u32 flags)
+{
+ // TODO: Flip/mirror
+ s32 current_x, current_y;
+ u32 current_u, current_v;
+ u32 primitive_color = psx_gpu->primitive_color;
+ u32 sprite_r, sprite_g, sprite_b;
+ s32 color_r = 0;
+ s32 color_g = 0;
+ s32 color_b = 0;
+ u32 texel = 0;
+
+ sprite_r = primitive_color & 0xFF;
+ sprite_g = (primitive_color >> 8) & 0xFF;
+ sprite_b = (primitive_color >> 16) & 0xFF;
+
+ static u32 sprites = 0;
+
+ sprites++;
+
+ for(current_y = y, current_v = v;
+ current_y < y + height; current_y++, current_v++)
+ {
+ for(current_x = x, current_u = u;
+ current_x < x + width; current_x++, current_u++)
+ {
+ if((current_x >= psx_gpu->viewport_start_x) &&
+ (current_y >= psx_gpu->viewport_start_y) &&
+ (current_x <= psx_gpu->viewport_end_x) &&
+ (current_y <= psx_gpu->viewport_end_y))
+ {
+ if(psx_gpu->mask_evaluate &&
+ (psx_gpu->vram[(y * 1024) + current_x] & 0x8000))
+ {
+ continue;
+ }
+
+ if(flags & RENDER_FLAGS_TEXTURE_MAP)
+ {
+ texel = fetch_texel(psx_gpu, current_u, current_v);
+ if(texel == 0)
+ continue;
+
+ color_r = texel & 0x1F;
+ color_g = (texel >> 5) & 0x1F;
+ color_b = (texel >> 10) & 0x1F;
+
+ if((flags & RENDER_FLAGS_MODULATE_TEXELS) == 0)
+ {
+ color_r *= sprite_r;
+ color_g *= sprite_g;
+ color_b *= sprite_b;
+
+ color_r >>= 7;
+ color_g >>= 7;
+ color_b >>= 7;
+ }
+ }
+ else
+ {
+ color_r = sprite_r >> 3;
+ color_g = sprite_g >> 3;
+ color_b = sprite_b >> 3;
+ }
+
+ draw_pixel(psx_gpu, color_r, color_g, color_b, texel, current_x,
+ current_y, flags);
+ }
+ }
+ }
+}
+
+
+#define draw_pixel_line(_x, _y) \
+ if((_x >= psx_gpu->viewport_start_x) && (_y >= psx_gpu->viewport_start_y) && \
+ (_x <= psx_gpu->viewport_end_x) && (_y <= psx_gpu->viewport_end_y)) \
+ { \
+ if(flags & RENDER_FLAGS_SHADE) \
+ { \
+ color_r = fixed_to_int(current_r); \
+ color_g = fixed_to_int(current_g); \
+ color_b = fixed_to_int(current_b); \
+ \
+ current_r += gradient_r; \
+ current_g += gradient_g; \
+ current_b += gradient_b; \
+ } \
+ else \
+ { \
+ color_r = primitive_color & 0xFF; \
+ color_g = (primitive_color >> 8) & 0xFF; \
+ color_b = (primitive_color >> 16) & 0xFF; \
+ } \
+ \
+ if(psx_gpu->dither_mode) \
+ { \
+ s32 dither_offset = dither_table[_y % 4][_x % 4]; \
+ \
+ color_r += dither_offset; \
+ color_g += dither_offset; \
+ color_b += dither_offset; \
+ \
+ if(color_r < 0) \
+ color_r = 0; \
+ \
+ if(color_g < 0) \
+ color_g = 0; \
+ \
+ if(color_b < 0) \
+ color_b = 0; \
+ } \
+ color_r >>= 3; \
+ color_g >>= 3; \
+ color_b >>= 3; \
+ \
+ span_pixels++; \
+ \
+ draw_pixel(psx_gpu, color_r, color_g, color_b, 0, _x, _y, flags); \
+ } \
+
+#define update_increment(value) \
+ value++ \
+
+#define update_decrement(value) \
+ value-- \
+
+#define compare_increment(a, b) \
+ (a <= b) \
+
+#define compare_decrement(a, b) \
+ (a >= b) \
+
+#define set_line_gradients(minor) \
+{ \
+ s32 gradient_divisor = delta_##minor; \
+ gradient_r = int_to_fixed(vertex_b->r - vertex_a->r) / gradient_divisor; \
+ gradient_g = int_to_fixed(vertex_b->g - vertex_a->g) / gradient_divisor; \
+ gradient_b = int_to_fixed(vertex_b->b - vertex_a->b) / gradient_divisor; \
+ current_r = fixed_center(vertex_a->r); \
+ current_g = fixed_center(vertex_a->g); \
+ current_b = fixed_center(vertex_a->b); \
+}
+
+#define draw_line_span_horizontal(direction) \
+do \
+{ \
+ error_step = delta_y * 2; \
+ error_wrap = delta_x * 2; \
+ error = delta_x; \
+ \
+ current_y = y_a; \
+ set_line_gradients(x); \
+ \
+ for(current_x = x_a; current_x <= x_b; current_x++) \
+ { \
+ draw_pixel_line(current_x, current_y); \
+ error += error_step; \
+ \
+ if(error >= error_wrap) \
+ { \
+ update_##direction(current_y); \
+ error -= error_wrap; \
+ } \
+ } \
+} while(0) \
+
+#define draw_line_span_vertical(direction) \
+do \
+{ \
+ error_step = delta_x * 2; \
+ error_wrap = delta_y * 2; \
+ error = delta_y; \
+ \
+ current_x = x_a; \
+ set_line_gradients(y); \
+ \
+ for(current_y = y_a; compare_##direction(current_y, y_b); \
+ update_##direction(current_y)) \
+ { \
+ draw_pixel_line(current_x, current_y); \
+ error += error_step; \
+ \
+ if(error > error_wrap) \
+ { \
+ current_x++; \
+ error -= error_wrap; \
+ } \
+ } \
+} while(0) \
+
+void render_line(psx_gpu_struct *psx_gpu, vertex_struct *vertexes, u32 flags)
+{
+ u32 primitive_color = psx_gpu->primitive_color;
+ s32 color_r, color_g, color_b;
+
+ fixed_type gradient_r = 0;
+ fixed_type gradient_g = 0;
+ fixed_type gradient_b = 0;
+ fixed_type current_r = 0;
+ fixed_type current_g = 0;
+ fixed_type current_b = 0;
+
+ s32 y_a, y_b;
+ s32 x_a, x_b;
+
+ s32 delta_x, delta_y;
+ u32 triangle_winding = 0;
+
+ s32 current_x;
+ s32 current_y;
+
+ u32 error_step;
+ u32 error;
+ u32 error_wrap;
+
+ vertex_struct *vertex_a = &(vertexes[0]);
+ vertex_struct *vertex_b = &(vertexes[1]);
+
+ if(vertex_a->x >= vertex_b->x)
+ {
+ vertex_swap(vertex_a, vertex_b);
+ }
+
+ x_a = vertex_a->x;
+ x_b = vertex_b->x;
+
+ y_a = vertex_a->y;
+ y_b = vertex_b->y;
+
+ delta_x = x_b - x_a;
+ delta_y = y_b - y_a;
+
+ if(delta_x >= 1024)
+ return;
+
+ flags &= ~RENDER_FLAGS_TEXTURE_MAP;
+
+ if(delta_y < 0)
+ {
+ delta_y *= -1;
+
+ if(delta_y >= 512)
+ return;
+
+ if(delta_x > delta_y)
+ draw_line_span_horizontal(decrement);
+ else
+ draw_line_span_vertical(decrement);
+ }
+ else
+ {
+ if(delta_y >= 512)
+ return;
+
+ if(delta_x > delta_y)
+ draw_line_span_horizontal(increment);
+ else
+ draw_line_span_vertical(increment);
+ }
+}
+
+
+void render_block_fill(psx_gpu_struct *psx_gpu, u32 color, u32 x, u32 y,
+ u32 width, u32 height)
+{
+ u32 r = color & 0xFF;
+ u32 g = (color >> 8) & 0xFF;
+ u32 b = (color >> 16) & 0xFF;
+ u32 color_16bpp = (r >> 3) | ((g >> 3) << 5) | ((b >> 3) << 10);
+
+ u16 *vram_ptr = psx_gpu->vram + x + (y * 1024);
+ u32 draw_x, draw_y;
+
+ for(draw_y = 0; draw_y < height; draw_y++)
+ {
+ for(draw_x = 0; draw_x < width; draw_x++)
+ {
+ vram_ptr[draw_x] = color_16bpp;
+ }
+
+ vram_ptr += 1024;
+ }
+}
+
+void render_block_copy(psx_gpu_struct *psx_gpu, u16 *source, u32 x, u32 y,
+ u32 width, u32 height, u32 pitch)
+{
+ u16 *vram_ptr = psx_gpu->vram + x + (y * 1024);
+ u32 draw_x, draw_y;
+
+ for(draw_y = 0; draw_y < height; draw_y++)
+ {
+ for(draw_x = 0; draw_x < width; draw_x++)
+ {
+ vram_ptr[draw_x] = source[draw_x];
+ }
+
+ source += pitch;
+ vram_ptr += 1024;
+ }
+}
+
+void render_block_move(psx_gpu_struct *psx_gpu, u32 source_x, u32 source_y,
+ u32 dest_x, u32 dest_y, u32 width, u32 height)
+{
+ render_block_copy(psx_gpu, psx_gpu->vram + source_x + (source_y * 1024),
+ dest_x, dest_y, width, height, 1024);
+}
+
+void initialize_psx_gpu(psx_gpu_struct *psx_gpu)
+{
+ psx_gpu->pixel_count_mode = 0;
+ psx_gpu->pixel_compare_mode = 0;
+
+ psx_gpu->vram_pixel_counts_a = malloc(sizeof(u8) * 1024 * 512);
+ psx_gpu->vram_pixel_counts_b = malloc(sizeof(u8) * 1024 * 512);
+ memset(psx_gpu->vram_pixel_counts_a, 0, sizeof(u8) * 1024 * 512);
+ memset(psx_gpu->vram_pixel_counts_b, 0, sizeof(u8) * 1024 * 512);
+ psx_gpu->compare_vram = malloc(sizeof(u16) * 1024 * 512);
+}
notaz.gp2x.de / pcsx_rearmed.git / blobdiff