From 5a079a2d114f96d4847d1ee305d5b7c16eeec50e Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Sat, 27 Dec 2025 12:03:39 -0800 Subject: Initial commit --- .../SDL-3.2.8/src/render/software/SDL_triangle.c | 945 +++++++++++++++++++++ 1 file changed, 945 insertions(+) create mode 100644 contrib/SDL-3.2.8/src/render/software/SDL_triangle.c (limited to 'contrib/SDL-3.2.8/src/render/software/SDL_triangle.c') diff --git a/contrib/SDL-3.2.8/src/render/software/SDL_triangle.c b/contrib/SDL-3.2.8/src/render/software/SDL_triangle.c new file mode 100644 index 0000000..c4e16d1 --- /dev/null +++ b/contrib/SDL-3.2.8/src/render/software/SDL_triangle.c @@ -0,0 +1,945 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ +#include "SDL_internal.h" + +#ifdef SDL_VIDEO_RENDER_SW + +#include + +#include "SDL_triangle.h" + +#include "../../video/SDL_surface_c.h" + +/* fixed points bits precision + * Set to 1, so that it can start rendering with middle of a pixel precision. + * It doesn't need to be increased. + * But, if increased too much, it overflows (srcx, srcy) coordinates used for filling with texture. + * (which could be turned to int64). + */ +#define FP_BITS 1 + +#define COLOR_EQ(c1, c2) ((c1).r == (c2).r && (c1).g == (c2).g && (c1).b == (c2).b && (c1).a == (c2).a) + +static void SDL_BlitTriangle_Slow(SDL_BlitInfo *info, + SDL_Point s2_x_area, SDL_Rect dstrect, int area, int bias_w0, int bias_w1, int bias_w2, + int d2d1_y, int d1d2_x, int d0d2_y, int d2d0_x, int d1d0_y, int d0d1_x, + int s2s0_x, int s2s1_x, int s2s0_y, int s2s1_y, int w0_row, int w1_row, int w2_row, + SDL_Color c0, SDL_Color c1, SDL_Color c2, bool is_uniform, SDL_TextureAddressMode texture_address_mode); + +#if 0 +bool SDL_BlitTriangle(SDL_Surface *src, const SDL_Point srcpoints[3], SDL_Surface *dst, const SDL_Point dstpoints[3]) +{ + int i; + SDL_Point points[6]; + + if (src == NULL || dst == NULL) { + return false; + } + + for (i = 0; i < 3; i++) { + if (srcpoints[i].x < 0 || srcpoints[i].y < 0 || srcpoints[i].x >= src->w || srcpoints[i].y >= src->h) { + return SDL_SetError("Values of 'srcpoints' out of bounds"); + } + } + + points[0] = srcpoints[0]; + points[1] = dstpoints[0]; + points[2] = srcpoints[1]; + points[3] = dstpoints[1]; + points[4] = srcpoints[2]; + points[5] = dstpoints[2]; + for (i = 0; i < 3; i++) { + trianglepoint_2_fixedpoint(&points[2 * i + 1]); + } + return SDL_SW_BlitTriangle(src, dst, points); +} + +bool SDL_FillTriangle(SDL_Surface *dst, const SDL_Point points[3], Uint32 color) +{ + int i; + SDL_Point points_tmp[3]; + if (dst == NULL) { + return false; + } + for (i = 0; i < 3; i++) { + points_tmp[i] = points[i]; + trianglepoint_2_fixedpoint(&points_tmp[i]); + } + return SDL_SW_FillTriangle(dst, points_tmp, SDL_BLENDMODE_NONE, color); +} +#endif + +// cross product AB x AC +static Sint64 cross_product(const SDL_Point *a, const SDL_Point *b, int c_x, int c_y) +{ + return ((Sint64)(b->x - a->x)) * ((Sint64)(c_y - a->y)) - ((Sint64)(b->y - a->y)) * ((Sint64)(c_x - a->x)); +} + +// check for top left rules +static bool is_top_left(const SDL_Point *a, const SDL_Point *b, int is_clockwise) +{ + if (is_clockwise) { + if (a->y == b->y && a->x < b->x) { + return true; + } + if (b->y < a->y) { + return true; + } + } else { + if (a->y == b->y && b->x < a->x) { + return true; + } + if (a->y < b->y) { + return true; + } + } + return false; +} + +// x = (y << FP_BITS) +// prevent runtime error: left shift of negative value +#define PRECOMP(x, y) \ + val = y; \ + if (val >= 0) { \ + x = val << FP_BITS; \ + } else { \ + val *= -1; \ + x = val << FP_BITS; \ + x *= -1; \ + } + +void trianglepoint_2_fixedpoint(SDL_Point *a) +{ + int val; + PRECOMP(a->x, a->x); + PRECOMP(a->y, a->y); +} + +// bounding rect of three points (in fixed point) +static void bounding_rect_fixedpoint(const SDL_Point *a, const SDL_Point *b, const SDL_Point *c, SDL_Rect *r) +{ + int min_x = SDL_min(a->x, SDL_min(b->x, c->x)); + int max_x = SDL_max(a->x, SDL_max(b->x, c->x)); + int min_y = SDL_min(a->y, SDL_min(b->y, c->y)); + int max_y = SDL_max(a->y, SDL_max(b->y, c->y)); + // points are in fixed point, shift back + r->x = min_x >> FP_BITS; + r->y = min_y >> FP_BITS; + r->w = (max_x - min_x) >> FP_BITS; + r->h = (max_y - min_y) >> FP_BITS; +} + +// bounding rect of three points +static void bounding_rect(const SDL_Point *a, const SDL_Point *b, const SDL_Point *c, SDL_Rect *r) +{ + int min_x = SDL_min(a->x, SDL_min(b->x, c->x)); + int max_x = SDL_max(a->x, SDL_max(b->x, c->x)); + int min_y = SDL_min(a->y, SDL_min(b->y, c->y)); + int max_y = SDL_max(a->y, SDL_max(b->y, c->y)); + r->x = min_x; + r->y = min_y; + r->w = (max_x - min_x); + r->h = (max_y - min_y); +} + +/* Triangle rendering, using Barycentric coordinates (w0, w1, w2) + * + * The cross product isn't computed from scratch at each iteration, + * but optimized using constant step increments + * + */ + +#define TRIANGLE_BEGIN_LOOP \ + { \ + int x, y; \ + for (y = 0; y < dstrect.h; y++) { \ + /* y start */ \ + Sint64 w0 = w0_row; \ + Sint64 w1 = w1_row; \ + Sint64 w2 = w2_row; \ + for (x = 0; x < dstrect.w; x++) { \ + /* In triangle */ \ + if (w0 + bias_w0 >= 0 && w1 + bias_w1 >= 0 && w2 + bias_w2 >= 0) { \ + Uint8 *dptr = (Uint8 *)dst_ptr + x * dstbpp; + +// Use 64 bits precision to prevent overflow when interpolating color / texture with wide triangles +#define TRIANGLE_GET_TEXTCOORD \ + int srcx = (int)(((Sint64)w0 * s2s0_x + (Sint64)w1 * s2s1_x + s2_x_area.x) / area); \ + int srcy = (int)(((Sint64)w0 * s2s0_y + (Sint64)w1 * s2s1_y + s2_x_area.y) / area); \ + if (texture_address_mode == SDL_TEXTURE_ADDRESS_WRAP) { \ + srcx %= src_surface->w; \ + if (srcx < 0) { \ + srcx += (src_surface->w - 1); \ + } \ + srcy %= src_surface->h; \ + if (srcy < 0) { \ + srcy += (src_surface->h - 1); \ + } \ + } + +#define TRIANGLE_GET_MAPPED_COLOR \ + Uint8 r = (Uint8)(((Sint64)w0 * c0.r + (Sint64)w1 * c1.r + (Sint64)w2 * c2.r) / area); \ + Uint8 g = (Uint8)(((Sint64)w0 * c0.g + (Sint64)w1 * c1.g + (Sint64)w2 * c2.g) / area); \ + Uint8 b = (Uint8)(((Sint64)w0 * c0.b + (Sint64)w1 * c1.b + (Sint64)w2 * c2.b) / area); \ + Uint8 a = (Uint8)(((Sint64)w0 * c0.a + (Sint64)w1 * c1.a + (Sint64)w2 * c2.a) / area); \ + Uint32 color = SDL_MapRGBA(format, palette, r, g, b, a); + +#define TRIANGLE_GET_COLOR \ + int r = (int)(((Sint64)w0 * c0.r + (Sint64)w1 * c1.r + (Sint64)w2 * c2.r) / area); \ + int g = (int)(((Sint64)w0 * c0.g + (Sint64)w1 * c1.g + (Sint64)w2 * c2.g) / area); \ + int b = (int)(((Sint64)w0 * c0.b + (Sint64)w1 * c1.b + (Sint64)w2 * c2.b) / area); \ + int a = (int)(((Sint64)w0 * c0.a + (Sint64)w1 * c1.a + (Sint64)w2 * c2.a) / area); + +#define TRIANGLE_END_LOOP \ + } \ + /* x += 1 */ \ + w0 += d2d1_y; \ + w1 += d0d2_y; \ + w2 += d1d0_y; \ + } \ + /* y += 1 */ \ + w0_row += d1d2_x; \ + w1_row += d2d0_x; \ + w2_row += d0d1_x; \ + dst_ptr += dst_pitch; \ + } \ + } + +bool SDL_SW_FillTriangle(SDL_Surface *dst, SDL_Point *d0, SDL_Point *d1, SDL_Point *d2, SDL_BlendMode blend, SDL_Color c0, SDL_Color c1, SDL_Color c2) +{ + bool result = true; + int dst_locked = 0; + + SDL_Rect dstrect; + + int dstbpp; + Uint8 *dst_ptr; + int dst_pitch; + + Sint64 area; + int is_clockwise; + + int d2d1_y, d1d2_x, d0d2_y, d2d0_x, d1d0_y, d0d1_x; + Sint64 w0_row, w1_row, w2_row; + int bias_w0, bias_w1, bias_w2; + + bool is_uniform; + + SDL_Surface *tmp = NULL; + + if (!SDL_SurfaceValid(dst)) { + return false; + } + + area = cross_product(d0, d1, d2->x, d2->y); + + is_uniform = COLOR_EQ(c0, c1) && COLOR_EQ(c1, c2); + + // Flat triangle + if (area == 0) { + return true; + } + + // Lock the destination, if needed + if (SDL_MUSTLOCK(dst)) { + if (!SDL_LockSurface(dst)) { + result = false; + goto end; + } else { + dst_locked = 1; + } + } + + bounding_rect_fixedpoint(d0, d1, d2, &dstrect); + + { + // Clip triangle rect with surface rect + SDL_Rect rect; + rect.x = 0; + rect.y = 0; + rect.w = dst->w; + rect.h = dst->h; + SDL_GetRectIntersection(&dstrect, &rect, &dstrect); + } + + { + // Clip triangle with surface clip rect + SDL_Rect rect; + SDL_GetSurfaceClipRect(dst, &rect); + SDL_GetRectIntersection(&dstrect, &rect, &dstrect); + } + + if (blend != SDL_BLENDMODE_NONE) { + SDL_PixelFormat format = dst->format; + + // need an alpha format + if (!SDL_ISPIXELFORMAT_ALPHA(format)) { + format = SDL_PIXELFORMAT_ARGB8888; + } + + // Use an intermediate surface + tmp = SDL_CreateSurface(dstrect.w, dstrect.h, format); + if (!tmp) { + result = false; + goto end; + } + + if (blend == SDL_BLENDMODE_MOD) { + Uint32 c = SDL_MapSurfaceRGBA(tmp, 255, 255, 255, 255); + SDL_FillSurfaceRect(tmp, NULL, c); + } + + SDL_SetSurfaceBlendMode(tmp, blend); + + dstbpp = tmp->fmt->bytes_per_pixel; + dst_ptr = (Uint8 *)tmp->pixels; + dst_pitch = tmp->pitch; + + } else { + // Write directly to destination surface + dstbpp = dst->fmt->bytes_per_pixel; + dst_ptr = (Uint8 *)dst->pixels + dstrect.x * dstbpp + dstrect.y * dst->pitch; + dst_pitch = dst->pitch; + } + + is_clockwise = area > 0; + if (area < 0) { + area = -area; + } + + { + int val; + PRECOMP(d2d1_y, d1->y - d2->y) + PRECOMP(d0d2_y, d2->y - d0->y) + PRECOMP(d1d0_y, d0->y - d1->y) + PRECOMP(d1d2_x, d2->x - d1->x) + PRECOMP(d2d0_x, d0->x - d2->x) + PRECOMP(d0d1_x, d1->x - d0->x) + } + + // Starting point for rendering, at the middle of a pixel + { + SDL_Point p; + p.x = dstrect.x; + p.y = dstrect.y; + trianglepoint_2_fixedpoint(&p); + p.x += (1 << FP_BITS) / 2; + p.y += (1 << FP_BITS) / 2; + w0_row = cross_product(d1, d2, p.x, p.y); + w1_row = cross_product(d2, d0, p.x, p.y); + w2_row = cross_product(d0, d1, p.x, p.y); + } + + // Handle anti-clockwise triangles + if (!is_clockwise) { + d2d1_y *= -1; + d0d2_y *= -1; + d1d0_y *= -1; + d1d2_x *= -1; + d2d0_x *= -1; + d0d1_x *= -1; + w0_row *= -1; + w1_row *= -1; + w2_row *= -1; + } + + // Add a bias to respect top-left rasterization rule + bias_w0 = (is_top_left(d1, d2, is_clockwise) ? 0 : -1); + bias_w1 = (is_top_left(d2, d0, is_clockwise) ? 0 : -1); + bias_w2 = (is_top_left(d0, d1, is_clockwise) ? 0 : -1); + + if (is_uniform) { + Uint32 color; + if (tmp) { + color = SDL_MapSurfaceRGBA(tmp, c0.r, c0.g, c0.b, c0.a); + } else { + color = SDL_MapSurfaceRGBA(dst, c0.r, c0.g, c0.b, c0.a); + } + + if (dstbpp == 4) { + TRIANGLE_BEGIN_LOOP + { + *(Uint32 *)dptr = color; + } + TRIANGLE_END_LOOP + } else if (dstbpp == 3) { + TRIANGLE_BEGIN_LOOP + { + Uint8 *s = (Uint8 *)&color; + dptr[0] = s[0]; + dptr[1] = s[1]; + dptr[2] = s[2]; + } + TRIANGLE_END_LOOP + } else if (dstbpp == 2) { + TRIANGLE_BEGIN_LOOP + { + *(Uint16 *)dptr = (Uint16)color; + } + TRIANGLE_END_LOOP + } else if (dstbpp == 1) { + TRIANGLE_BEGIN_LOOP + { + *dptr = (Uint8)color; + } + TRIANGLE_END_LOOP + } + } else { + const SDL_PixelFormatDetails *format; + SDL_Palette *palette; + if (tmp) { + format = tmp->fmt; + palette = tmp->palette; + } else { + format = dst->fmt; + palette = dst->palette; + } + if (dstbpp == 4) { + TRIANGLE_BEGIN_LOOP + { + TRIANGLE_GET_MAPPED_COLOR + *(Uint32 *)dptr = color; + } + TRIANGLE_END_LOOP + } else if (dstbpp == 3) { + TRIANGLE_BEGIN_LOOP + { + TRIANGLE_GET_MAPPED_COLOR + Uint8 *s = (Uint8 *)&color; + dptr[0] = s[0]; + dptr[1] = s[1]; + dptr[2] = s[2]; + } + TRIANGLE_END_LOOP + } else if (dstbpp == 2) { + TRIANGLE_BEGIN_LOOP + { + TRIANGLE_GET_MAPPED_COLOR + *(Uint16 *)dptr = (Uint16)color; + } + TRIANGLE_END_LOOP + } else if (dstbpp == 1) { + TRIANGLE_BEGIN_LOOP + { + TRIANGLE_GET_MAPPED_COLOR + *dptr = (Uint8)color; + } + TRIANGLE_END_LOOP + } + } + + if (tmp) { + SDL_BlitSurface(tmp, NULL, dst, &dstrect); + SDL_DestroySurface(tmp); + } + +end: + if (dst_locked) { + SDL_UnlockSurface(dst); + } + + return result; +} + +bool SDL_SW_BlitTriangle( + SDL_Surface *src, + SDL_Point *s0, SDL_Point *s1, SDL_Point *s2, + SDL_Surface *dst, + SDL_Point *d0, SDL_Point *d1, SDL_Point *d2, + SDL_Color c0, SDL_Color c1, SDL_Color c2, + SDL_TextureAddressMode texture_address_mode) +{ + bool result = true; + SDL_Surface *src_surface = src; + int src_locked = 0; + int dst_locked = 0; + + SDL_BlendMode blend; + + SDL_Rect dstrect; + + SDL_Point s2_x_area; + + int dstbpp; + Uint8 *dst_ptr; + int dst_pitch; + + const int *src_ptr; + int src_pitch; + + Sint64 area, tmp64; + int is_clockwise; + + int d2d1_y, d1d2_x, d0d2_y, d2d0_x, d1d0_y, d0d1_x; + int s2s0_x, s2s1_x, s2s0_y, s2s1_y; + + Sint64 w0_row, w1_row, w2_row; + int bias_w0, bias_w1, bias_w2; + + bool is_uniform; + + bool has_modulation; + + if (!SDL_SurfaceValid(src)) { + return SDL_InvalidParamError("src"); + } + if (!SDL_SurfaceValid(dst)) { + return SDL_InvalidParamError("dst"); + } + + area = cross_product(d0, d1, d2->x, d2->y); + + // Flat triangle + if (area == 0) { + return true; + } + + // Lock the destination, if needed + if (SDL_MUSTLOCK(dst)) { + if (!SDL_LockSurface(dst)) { + result = false; + goto end; + } else { + dst_locked = 1; + } + } + + // Lock the source, if needed + if (SDL_MUSTLOCK(src)) { + if (!SDL_LockSurface(src)) { + result = false; + goto end; + } else { + src_locked = 1; + } + } + + is_uniform = COLOR_EQ(c0, c1) && COLOR_EQ(c1, c2); + + bounding_rect_fixedpoint(d0, d1, d2, &dstrect); + + SDL_GetSurfaceBlendMode(src, &blend); + + // TRIANGLE_GET_TEXTCOORD interpolates up to the max values included, so reduce by 1 + if (texture_address_mode == SDL_TEXTURE_ADDRESS_CLAMP) { + SDL_Rect srcrect; + int maxx, maxy; + bounding_rect(s0, s1, s2, &srcrect); + maxx = srcrect.x + srcrect.w; + maxy = srcrect.y + srcrect.h; + if (srcrect.w > 0) { + if (s0->x == maxx) { + s0->x--; + } + if (s1->x == maxx) { + s1->x--; + } + if (s2->x == maxx) { + s2->x--; + } + } + if (srcrect.h > 0) { + if (s0->y == maxy) { + s0->y--; + } + if (s1->y == maxy) { + s1->y--; + } + if (s2->y == maxy) { + s2->y--; + } + } + } + + if (is_uniform) { + // SDL_GetSurfaceColorMod(src, &r, &g, &b); + has_modulation = c0.r != 255 || c0.g != 255 || c0.b != 255 || c0.a != 255; + } else { + has_modulation = true; + } + + { + // Clip triangle with surface clip rect + SDL_Rect rect; + SDL_GetSurfaceClipRect(dst, &rect); + SDL_GetRectIntersection(&dstrect, &rect, &dstrect); + } + + // Set destination pointer + dstbpp = dst->fmt->bytes_per_pixel; + dst_ptr = (Uint8 *)dst->pixels + dstrect.x * dstbpp + dstrect.y * dst->pitch; + dst_pitch = dst->pitch; + + // Set source pointer + src_ptr = (const int *)src->pixels; + src_pitch = src->pitch; + + is_clockwise = area > 0; + if (area < 0) { + area = -area; + } + + { + int val; + PRECOMP(d2d1_y, d1->y - d2->y) + PRECOMP(d0d2_y, d2->y - d0->y) + PRECOMP(d1d0_y, d0->y - d1->y) + PRECOMP(d1d2_x, d2->x - d1->x) + PRECOMP(d2d0_x, d0->x - d2->x) + PRECOMP(d0d1_x, d1->x - d0->x) + } + + s2s0_x = s0->x - s2->x; + s2s1_x = s1->x - s2->x; + s2s0_y = s0->y - s2->y; + s2s1_y = s1->y - s2->y; + + // Starting point for rendering, at the middle of a pixel + { + SDL_Point p; + p.x = dstrect.x; + p.y = dstrect.y; + trianglepoint_2_fixedpoint(&p); + p.x += (1 << FP_BITS) / 2; + p.y += (1 << FP_BITS) / 2; + w0_row = cross_product(d1, d2, p.x, p.y); + w1_row = cross_product(d2, d0, p.x, p.y); + w2_row = cross_product(d0, d1, p.x, p.y); + } + + // Handle anti-clockwise triangles + if (!is_clockwise) { + d2d1_y *= -1; + d0d2_y *= -1; + d1d0_y *= -1; + d1d2_x *= -1; + d2d0_x *= -1; + d0d1_x *= -1; + w0_row *= -1; + w1_row *= -1; + w2_row *= -1; + } + + // Add a bias to respect top-left rasterization rule + bias_w0 = (is_top_left(d1, d2, is_clockwise) ? 0 : -1); + bias_w1 = (is_top_left(d2, d0, is_clockwise) ? 0 : -1); + bias_w2 = (is_top_left(d0, d1, is_clockwise) ? 0 : -1); + + /* precompute constant 's2->x * area' used in TRIANGLE_GET_TEXTCOORD */ + tmp64 = s2->x * area; + if (tmp64 >= INT_MIN && tmp64 <= INT_MAX) { + s2_x_area.x = (int)tmp64; + } else { + result = SDL_SetError("triangle area overflow"); + goto end; + } + tmp64 = s2->y * area; + if (tmp64 >= INT_MIN && tmp64 <= INT_MAX) { + s2_x_area.y = (int)tmp64; + } else { + result = SDL_SetError("triangle area overflow"); + goto end; + } + + if (blend != SDL_BLENDMODE_NONE || src->format != dst->format || has_modulation || !is_uniform) { + // Use SDL_BlitTriangle_Slow + + SDL_BlitInfo *info = &src->map.info; + SDL_BlitInfo tmp_info; + + SDL_zero(tmp_info); + + tmp_info.src_fmt = src->fmt; + tmp_info.dst_fmt = dst->fmt; + tmp_info.flags = info->flags; + /* + tmp_info.r = info->r; + tmp_info.g = info->g; + tmp_info.b = info->b; + tmp_info.a = info->a; + */ + tmp_info.r = c0.r; + tmp_info.g = c0.g; + tmp_info.b = c0.b; + tmp_info.a = c0.a; + + tmp_info.flags &= ~(SDL_COPY_MODULATE_COLOR | SDL_COPY_MODULATE_ALPHA); + + if (c0.r != 255 || c1.r != 255 || c2.r != 255 || + c0.g != 255 || c1.g != 255 || c2.g != 255 || + c0.b != 255 || c1.b != 255 || c2.b != 255) { + tmp_info.flags |= SDL_COPY_MODULATE_COLOR; + } + + if (c0.a != 255 || c1.a != 255 || c2.a != 255) { + tmp_info.flags |= SDL_COPY_MODULATE_ALPHA; + } + + tmp_info.colorkey = info->colorkey; + + // src + tmp_info.src_surface = src_surface; + tmp_info.src = (Uint8 *)src_ptr; + tmp_info.src_pitch = src_pitch; + + // dst + tmp_info.dst = dst_ptr; + tmp_info.dst_pitch = dst_pitch; + +#define CHECK_INT_RANGE(X) \ + if ((X) < INT_MIN || (X) > INT_MAX) { \ + result = SDL_SetError("integer overflow (%s = %" SDL_PRIs64 ")", #X, X); \ + goto end; \ + } + CHECK_INT_RANGE(area); + CHECK_INT_RANGE(w0_row); + CHECK_INT_RANGE(w1_row); + CHECK_INT_RANGE(w2_row); + SDL_BlitTriangle_Slow(&tmp_info, s2_x_area, dstrect, (int)area, bias_w0, bias_w1, bias_w2, + d2d1_y, d1d2_x, d0d2_y, d2d0_x, d1d0_y, d0d1_x, + s2s0_x, s2s1_x, s2s0_y, s2s1_y, (int)w0_row, (int)w1_row, (int)w2_row, + c0, c1, c2, is_uniform, texture_address_mode); + + goto end; + } + + if (dstbpp == 4) { + TRIANGLE_BEGIN_LOOP + { + TRIANGLE_GET_TEXTCOORD + Uint32 *sptr = (Uint32 *)((Uint8 *)src_ptr + srcy * src_pitch); + *(Uint32 *)dptr = sptr[srcx]; + } + TRIANGLE_END_LOOP + } else if (dstbpp == 3) { + TRIANGLE_BEGIN_LOOP + { + TRIANGLE_GET_TEXTCOORD + Uint8 *sptr = (Uint8 *)src_ptr + srcy * src_pitch; + dptr[0] = sptr[3 * srcx]; + dptr[1] = sptr[3 * srcx + 1]; + dptr[2] = sptr[3 * srcx + 2]; + } + TRIANGLE_END_LOOP + } else if (dstbpp == 2) { + TRIANGLE_BEGIN_LOOP + { + TRIANGLE_GET_TEXTCOORD + Uint16 *sptr = (Uint16 *)((Uint8 *)src_ptr + srcy * src_pitch); + *(Uint16 *)dptr = sptr[srcx]; + } + TRIANGLE_END_LOOP + } else if (dstbpp == 1) { + TRIANGLE_BEGIN_LOOP + { + TRIANGLE_GET_TEXTCOORD + Uint8 *sptr = (Uint8 *)src_ptr + srcy * src_pitch; + *dptr = sptr[srcx]; + } + TRIANGLE_END_LOOP + } + +end: + if (dst_locked) { + SDL_UnlockSurface(dst); + } + if (src_locked) { + SDL_UnlockSurface(src); + } + + return result; +} + +#define FORMAT_ALPHA 0 +#define FORMAT_NO_ALPHA -1 +#define FORMAT_2101010 1 +#define FORMAT_HAS_ALPHA(format) format == 0 +#define FORMAT_HAS_NO_ALPHA(format) format < 0 +static int detect_format(const SDL_PixelFormatDetails *pf) +{ + if (pf->format == SDL_PIXELFORMAT_ARGB2101010) { + return FORMAT_2101010; + } else if (pf->Amask) { + return FORMAT_ALPHA; + } else { + return FORMAT_NO_ALPHA; + } +} + +static void SDL_BlitTriangle_Slow(SDL_BlitInfo *info, + SDL_Point s2_x_area, SDL_Rect dstrect, int area, int bias_w0, int bias_w1, int bias_w2, + int d2d1_y, int d1d2_x, int d0d2_y, int d2d0_x, int d1d0_y, int d0d1_x, + int s2s0_x, int s2s1_x, int s2s0_y, int s2s1_y, int w0_row, int w1_row, int w2_row, + SDL_Color c0, SDL_Color c1, SDL_Color c2, bool is_uniform, SDL_TextureAddressMode texture_address_mode) +{ + SDL_Surface *src_surface = info->src_surface; + const int flags = info->flags; + Uint32 modulateR = info->r; + Uint32 modulateG = info->g; + Uint32 modulateB = info->b; + Uint32 modulateA = info->a; + Uint32 srcpixel; + Uint32 srcR, srcG, srcB, srcA; + Uint32 dstpixel; + Uint32 dstR, dstG, dstB, dstA; + const SDL_PixelFormatDetails *src_fmt = info->src_fmt; + const SDL_PixelFormatDetails *dst_fmt = info->dst_fmt; + int srcbpp = src_fmt->bytes_per_pixel; + int dstbpp = dst_fmt->bytes_per_pixel; + int srcfmt_val; + int dstfmt_val; + Uint32 rgbmask = ~src_fmt->Amask; + Uint32 ckey = info->colorkey & rgbmask; + + Uint8 *dst_ptr = info->dst; + int dst_pitch = info->dst_pitch; + + srcfmt_val = detect_format(src_fmt); + dstfmt_val = detect_format(dst_fmt); + + TRIANGLE_BEGIN_LOOP + { + Uint8 *src; + Uint8 *dst = dptr; + TRIANGLE_GET_TEXTCOORD + src = (info->src + (srcy * info->src_pitch) + (srcx * srcbpp)); + if (FORMAT_HAS_ALPHA(srcfmt_val)) { + DISEMBLE_RGBA(src, srcbpp, src_fmt, srcpixel, srcR, srcG, srcB, srcA); + } else if (FORMAT_HAS_NO_ALPHA(srcfmt_val)) { + DISEMBLE_RGB(src, srcbpp, src_fmt, srcpixel, srcR, srcG, srcB); + srcA = 0xFF; + } else { + // SDL_PIXELFORMAT_ARGB2101010 + srcpixel = *((Uint32 *)(src)); + RGBA_FROM_ARGB2101010(srcpixel, srcR, srcG, srcB, srcA); + } + if (flags & SDL_COPY_COLORKEY) { + // srcpixel isn't set for 24 bpp + if (srcbpp == 3) { + srcpixel = (srcR << src_fmt->Rshift) | + (srcG << src_fmt->Gshift) | (srcB << src_fmt->Bshift); + } + if ((srcpixel & rgbmask) == ckey) { + continue; + } + } + if ((flags & (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_MUL))) { + if (FORMAT_HAS_ALPHA(dstfmt_val)) { + DISEMBLE_RGBA(dst, dstbpp, dst_fmt, dstpixel, dstR, dstG, dstB, dstA); + } else if (FORMAT_HAS_NO_ALPHA(dstfmt_val)) { + DISEMBLE_RGB(dst, dstbpp, dst_fmt, dstpixel, dstR, dstG, dstB); + dstA = 0xFF; + } else { + // SDL_PIXELFORMAT_ARGB2101010 + dstpixel = *((Uint32 *) (dst)); + RGBA_FROM_ARGB2101010(dstpixel, dstR, dstG, dstB, dstA); + } + } else { + // don't care + dstR = dstG = dstB = dstA = 0; + } + + if (!is_uniform) { + TRIANGLE_GET_COLOR + modulateR = r; + modulateG = g; + modulateB = b; + modulateA = a; + } + + if (flags & SDL_COPY_MODULATE_COLOR) { + srcR = (srcR * modulateR) / 255; + srcG = (srcG * modulateG) / 255; + srcB = (srcB * modulateB) / 255; + } + if (flags & SDL_COPY_MODULATE_ALPHA) { + srcA = (srcA * modulateA) / 255; + } + if (flags & (SDL_COPY_BLEND | SDL_COPY_ADD)) { + // This goes away if we ever use premultiplied alpha + if (srcA < 255) { + srcR = (srcR * srcA) / 255; + srcG = (srcG * srcA) / 255; + srcB = (srcB * srcA) / 255; + } + } + switch (flags & (SDL_COPY_BLEND | SDL_COPY_ADD | SDL_COPY_MOD | SDL_COPY_MUL)) { + case 0: + dstR = srcR; + dstG = srcG; + dstB = srcB; + dstA = srcA; + break; + case SDL_COPY_BLEND: + dstR = srcR + ((255 - srcA) * dstR) / 255; + dstG = srcG + ((255 - srcA) * dstG) / 255; + dstB = srcB + ((255 - srcA) * dstB) / 255; + dstA = srcA + ((255 - srcA) * dstA) / 255; + break; + case SDL_COPY_ADD: + dstR = srcR + dstR; + if (dstR > 255) { + dstR = 255; + } + dstG = srcG + dstG; + if (dstG > 255) { + dstG = 255; + } + dstB = srcB + dstB; + if (dstB > 255) { + dstB = 255; + } + break; + case SDL_COPY_MOD: + dstR = (srcR * dstR) / 255; + dstG = (srcG * dstG) / 255; + dstB = (srcB * dstB) / 255; + break; + case SDL_COPY_MUL: + dstR = ((srcR * dstR) + (dstR * (255 - srcA))) / 255; + if (dstR > 255) { + dstR = 255; + } + dstG = ((srcG * dstG) + (dstG * (255 - srcA))) / 255; + if (dstG > 255) { + dstG = 255; + } + dstB = ((srcB * dstB) + (dstB * (255 - srcA))) / 255; + if (dstB > 255) { + dstB = 255; + } + break; + } + if (FORMAT_HAS_ALPHA(dstfmt_val)) { + ASSEMBLE_RGBA(dst, dstbpp, dst_fmt, dstR, dstG, dstB, dstA); + } else if (FORMAT_HAS_NO_ALPHA(dstfmt_val)) { + ASSEMBLE_RGB(dst, dstbpp, dst_fmt, dstR, dstG, dstB); + } else { + // SDL_PIXELFORMAT_ARGB2101010 + Uint32 pixel; + ARGB2101010_FROM_RGBA(pixel, dstR, dstG, dstB, dstA); + *(Uint32 *)dst = pixel; + } + } + TRIANGLE_END_LOOP +} + +#endif // SDL_VIDEO_RENDER_SW -- cgit v1.2.3