[Scummvm-git-logs] scummvm master -> 585b112d6b5828be478bfedf91f7d76964d88459
sev-
sev at scummvm.org
Tue Jul 27 18:38:47 UTC 2021
This automated email contains information about 1 new commit which have been
pushed to the 'scummvm' repo located at https://github.com/scummvm/scummvm .
Summary:
585b112d6b GRAPHICS: Implement horizontal triangles
Commit: 585b112d6b5828be478bfedf91f7d76964d88459
https://github.com/scummvm/scummvm/commit/585b112d6b5828be478bfedf91f7d76964d88459
Author: Le Philousophe (lephilousophe at users.noreply.github.com)
Date: 2021-07-27T20:38:45+02:00
Commit Message:
GRAPHICS: Implement horizontal triangles
Simplify drawTriangle in the same time and fix a bad copy paste when
drawing outline with w == h
Changed paths:
graphics/VectorRendererSpec.cpp
graphics/VectorRendererSpec.h
diff --git a/graphics/VectorRendererSpec.cpp b/graphics/VectorRendererSpec.cpp
index 38db2469dc..2e7c651df6 100644
--- a/graphics/VectorRendererSpec.cpp
+++ b/graphics/VectorRendererSpec.cpp
@@ -501,6 +501,54 @@ void colorFillClip(PixelType *first, PixelType *last, PixelType color, int realX
}
}
+/**
+ * Fills several pixels in a column with a given color.
+ *
+ * @param first Pointer to the first pixel to fill.
+ * @param last Pointer to the last pixel to fill.
+ * @param pitch Number of pixels in a line.
+ * @param color Color of the pixel
+ */
+template<typename PixelType>
+void colorVFill(PixelType *first, PixelType *last, int pitch, PixelType color) {
+ int count = (last - first) / pitch;
+ if (!count)
+ return;
+ for (PixelType *p = first; count; p+= pitch, count--) {
+ *p = color;
+ }
+}
+
+template<typename PixelType>
+void colorVFillClip(PixelType *first, PixelType *last, int pitch, PixelType color, int realX, int realY, Common::Rect &clippingArea) {
+ if (realX < clippingArea.left || realX >= clippingArea.right)
+ return;
+
+ int count = (last - first) / pitch;
+
+ if (realY > clippingArea.bottom || realY + count < clippingArea.top)
+ return;
+
+ if (realY < clippingArea.top) {
+ int diff = (clippingArea.top - realY);
+ realY += diff;
+ first += diff * pitch;
+ count -= diff;
+ }
+
+ if (clippingArea.bottom <= realY + count) {
+ int diff = (realY + count - clippingArea.bottom);
+ count -= diff;
+ }
+
+ if (!count)
+ return;
+
+ for (PixelType *p = first; count; p+= pitch, count--) {
+ *p = color;
+ }
+}
+
VectorRenderer *createRenderer(int mode) {
#ifdef DISABLE_FANCY_THEMES
@@ -1315,58 +1363,37 @@ drawTriangle(int x, int y, int w, int h, TriangleOrientation orient) {
bool useClippingVersions = !_clippingArea.contains(Common::Rect(x, y, x + w, y + h));
- if (w == h) {
- int newW = w;
-
- switch (orient) {
- case kTriangleUp:
- case kTriangleDown:
- if (useClippingVersions)
- drawTriangleVertAlgClip(x, y, newW, newW, (orient == kTriangleDown), color, Base::_fillMode);
- else
- drawTriangleVertAlg(x, y, newW, newW, (orient == kTriangleDown), color, Base::_fillMode);
- break;
-
- case kTriangleLeft:
- case kTriangleRight:
- case kTriangleAuto:
- default:
- break;
- }
+ void (VectorRendererSpec<PixelType>::*drawFunc)(int x1, int y1, int w, int h, bool inverted, PixelType color, VectorRenderer::FillMode fill_m) = nullptr;
+ bool inverted = false;
- if (Base::_strokeWidth > 0)
- if (Base::_fillMode == kFillBackground || Base::_fillMode == kFillGradient) {
- if (useClippingVersions)
- drawTriangleVertAlgClip(x, y, newW, newW, (orient == kTriangleDown), color, Base::_fillMode);
- else
- drawTriangleVertAlg(x, y, newW, newW, (orient == kTriangleDown), color, Base::_fillMode);
- }
- } else {
- int newW = w;
- int newH = h;
-
- switch (orient) {
- case kTriangleUp:
- case kTriangleDown:
- if (useClippingVersions)
- drawTriangleVertAlgClip(x, y, newW, newH, (orient == kTriangleDown), color, Base::_fillMode);
- else
- drawTriangleVertAlg(x, y, newW, newH, (orient == kTriangleDown), color, Base::_fillMode);
- break;
+ switch (orient) {
+ case kTriangleUp:
+ case kTriangleDown:
+ if (useClippingVersions)
+ drawFunc = &VectorRendererSpec<PixelType>::drawTriangleVertAlgClip;
+ else
+ drawFunc = &VectorRendererSpec<PixelType>::drawTriangleVertAlg;
+ inverted = (orient == kTriangleDown);
+ break;
- case kTriangleLeft:
- case kTriangleRight:
- case kTriangleAuto:
- default:
- break;
- }
+ case kTriangleLeft:
+ case kTriangleRight:
+ if (useClippingVersions)
+ drawFunc = &VectorRendererSpec<PixelType>::drawTriangleHorzAlgClip;
+ else
+ drawFunc = &VectorRendererSpec<PixelType>::drawTriangleHorzAlg;
+ inverted = (orient == kTriangleRight);
+ break;
+ case kTriangleAuto:
+ default:
+ break;
+ }
+ if (drawFunc) {
+ (this->*drawFunc)(x, y, w, h, inverted, color, Base::_fillMode);
if (Base::_strokeWidth > 0) {
if (Base::_fillMode == kFillBackground || Base::_fillMode == kFillGradient) {
- if (useClippingVersions)
- drawTriangleVertAlgClip(x, y, newW, newH, (orient == kTriangleDown), _fgColor, kFillDisabled);
- else
- drawTriangleVertAlg(x, y, newW, newH, (orient == kTriangleDown), _fgColor, kFillDisabled);
+ (this->*drawFunc)(x, y, w, h, inverted, _fgColor, kFillDisabled);
}
}
}
@@ -2148,6 +2175,482 @@ drawLineAlgClip(int x1, int y1, int x2, int y2, uint dx, uint dy, PixelType colo
#define rfpart(x) (int)((1 - fpart(x)) * 100)
#endif
+template<typename PixelType>
+void VectorRendererSpec<PixelType>::
+drawTriangleHorzAlg(int x1, int y1, int w, int h, bool inverted, PixelType color, VectorRenderer::FillMode fill_m) {
+ // Don't draw anything for empty rects. This assures dy is always different
+ // from zero.
+ if (w <= 0 || h <= 0) {
+ return;
+ }
+
+ int pitch = _activeSurface->pitch / _activeSurface->format.bytesPerPixel;
+ int gradient_w = 0;
+ int x_pitch_sign = 1;
+ if (!inverted) {
+ x1 += w;
+ x_pitch_sign = -1;
+ }
+
+ PixelType *ptr_bottom = (PixelType *)_activeSurface->getBasePtr(x1, y1);
+ PixelType *floor = ptr_bottom - pitch;
+ PixelType *ptr_top = (PixelType *)_activeSurface->getBasePtr(x1, y1 + h);
+
+ int x2 = x1 + w;
+ int y2 = y1 + h / 2;
+
+#if FIXED_POINT
+ int dx = (x2 - x1) << 8;
+ int dy = (y2 - y1) << 8;
+
+ if (abs(dy) > abs(dx)) {
+#else
+ double dx = (double)x2 - (double)x1;
+ double dy = (double)y2 - (double)y1;
+
+ if (fabs(dy) > fabs(dx)) {
+#endif
+ while (floor != ptr_top) {
+ floor += pitch;
+ blendPixelPtr(floor, color, 50);
+ }
+
+#if FIXED_POINT
+ // In this branch dx is always different from zero. This is because
+ // abs(dx) is strictly greater than abs(dy), and abs returns zero
+ // as minimal value.
+ int gradient = (dx << 8) / dy;
+ int interx = (x1 << 8) + gradient;
+#else
+ double gradient = dx / dy;
+ double interx = x1 + gradient;
+#endif
+
+ for (int y = y1 + 1; y < y2; y++) {
+#if FIXED_POINT
+ if (interx + gradient >= ipart(interx) + 0x100) {
+#else
+ if (interx + gradient >= ipart(interx) + 1) {
+#endif
+ ptr_bottom += pitch;
+ ptr_top -= pitch;
+ }
+
+ ptr_top += x_pitch_sign;
+ ptr_bottom += x_pitch_sign;
+
+ interx += gradient;
+
+ switch (fill_m) {
+ case kFillDisabled:
+ *ptr_top = *ptr_bottom = color;
+ break;
+ case kFillForeground:
+ case kFillBackground:
+ colorVFill<PixelType>(ptr_bottom + pitch, ptr_top, pitch, color);
+ blendPixelPtr(ptr_bottom, color, rfpart(interx));
+ blendPixelPtr(ptr_top, color, rfpart(interx));
+ break;
+ case kFillGradient:
+ colorVFill<PixelType>(ptr_bottom, ptr_top, pitch, calcGradient(gradient_w++, w));
+ blendPixelPtr(ptr_bottom, color, rfpart(interx));
+ blendPixelPtr(ptr_top, color, rfpart(interx));
+ break;
+ default:
+ break;
+ }
+ }
+
+ return;
+ }
+
+#if FIXED_POINT
+ if (abs(dy) < abs(dx)) {
+#else
+ if (fabs(dy) < fabs(dx)) {
+#endif
+ ptr_top -= pitch;
+ while (floor != ptr_top) {
+ floor += pitch;
+ blendPixelPtr(floor, color, 50);
+ }
+
+#if FIXED_POINT
+ int gradient = (dy << 8) / (dx + 0x100);
+ int intery = (y1 << 8) + gradient;
+#else
+ double gradient = dy / (dx + 1);
+ double intery = y1 + gradient;
+#endif
+
+ for (int x = x1 + 1; x < x2; x++) {
+#if FIXED_POINT
+ if (intery + gradient >= ipart(intery) + 0x100) {
+#else
+ if (intery + gradient >= ipart(intery) + 1) {
+#endif
+ ptr_bottom += pitch;
+ ptr_top -= pitch;
+ }
+
+ ptr_top += x_pitch_sign;
+ ptr_bottom += x_pitch_sign;
+
+ intery += gradient;
+
+ switch (fill_m) {
+ case kFillDisabled:
+ *ptr_top = *ptr_bottom = color;
+ break;
+ case kFillForeground:
+ case kFillBackground:
+ colorVFill<PixelType>(ptr_bottom + pitch, ptr_top, pitch, color);
+ blendPixelPtr(ptr_bottom, color, rfpart(intery));
+ blendPixelPtr(ptr_top, color, rfpart(intery));
+ break;
+ case kFillGradient:
+ colorVFill<PixelType>(ptr_bottom, ptr_top, pitch, calcGradient(gradient_w++, w));
+ blendPixelPtr(ptr_bottom, color, rfpart(intery));
+ blendPixelPtr(ptr_top, color, rfpart(intery));
+ break;
+ default:
+ break;
+ }
+ }
+
+ return;
+ }
+
+ ptr_top -= pitch;
+
+ while (floor != ptr_top) {
+ floor += pitch;
+ blendPixelPtr(floor, color, 50);
+ }
+
+#if FIXED_POINT
+ int gradient = (dy / dx) << 8;
+ int intery = (y1 << 8) + gradient;
+#else
+ double gradient = dy / dx;
+ double intery = y1 + gradient;
+#endif
+
+ for (int x = x1 + 1; x < x2; x++) {
+ ptr_bottom += pitch;
+ ptr_top -= pitch;
+
+ ptr_top += x_pitch_sign;
+ ptr_bottom += x_pitch_sign;
+
+ intery += gradient;
+
+ switch (fill_m) {
+ case kFillDisabled:
+ *ptr_top = *ptr_bottom = color;
+ break;
+ case kFillForeground:
+ case kFillBackground:
+ colorVFill<PixelType>(ptr_bottom + pitch, ptr_top, pitch, color);
+ blendPixelPtr(ptr_bottom, color, rfpart(intery));
+ blendPixelPtr(ptr_top, color, rfpart(intery));
+ break;
+ case kFillGradient:
+ colorVFill<PixelType>(ptr_bottom, ptr_top, pitch, calcGradient(gradient_w++, w));
+ blendPixelPtr(ptr_bottom, color, rfpart(intery));
+ blendPixelPtr(ptr_top, color, rfpart(intery));
+ break;
+ default:
+ break;
+ }
+ }
+
+}
+
+/////////////
+
+template<typename PixelType>
+void VectorRendererSpec<PixelType>::
+drawTriangleHorzAlgClip(int x1, int y1, int w, int h, bool inverted, PixelType color, VectorRenderer::FillMode fill_m) {
+ // Don't draw anything for empty rects. This assures dy is always different
+ // from zero.
+ if (w <= 0 || h <= 0) {
+ return;
+ }
+
+ int pitch = _activeSurface->pitch / _activeSurface->format.bytesPerPixel;
+ int gradient_w = 0;
+ int x_pitch_sign = 1;
+ if (!inverted) {
+ x1 += w;
+ x_pitch_sign = -1;
+ }
+
+ PixelType *ptr_bottom = (PixelType *)_activeSurface->getBasePtr(x1, y1);
+ PixelType *floor = ptr_bottom - pitch;
+ PixelType *ptr_top = (PixelType *)_activeSurface->getBasePtr(x1, y1 + h);
+
+ int x2 = x1 + w;
+ int y2 = y1 + h / 2;
+ int x_bottom = x1;
+ int y_bottom = y1;
+ int x_top = x1;
+ int y_top = y1 + h;
+ int x_floor = x_bottom;
+ int y_floor = y_bottom - 1;
+
+#if FIXED_POINT
+ int dx = (x2 - x1) << 8;
+ int dy = (y2 - y1) << 8;
+
+ if (abs(dy) > abs(dx)) {
+#else
+ double dx = (double)x2 - (double)x1;
+ double dy = (double)y2 - (double)y1;
+
+ if (fabs(dy) > fabs(dx)) {
+#endif
+ while (floor != ptr_top) {
+ floor += pitch;
+ blendPixelPtrClip(floor, color, 50, x_floor, ++y_floor);
+ }
+
+#if FIXED_POINT
+ // In this branch dx is always different from zero. This is because
+ // abs(dx) is strictly greater than abs(dy), and abs returns zero
+ // as minimal value.
+ int gradient = (dx << 8) / dy;
+ int interx = (x1 << 8) + gradient;
+#else
+ double gradient = dx / dy;
+ double interx = x1 + gradient;
+#endif
+
+ for (int y = y1 + 1; y < y2; y++) {
+#if FIXED_POINT
+ if (interx + gradient >= ipart(interx) + 0x100) {
+#else
+ if (interx + gradient >= ipart(interx) + 1) {
+#endif
+ ptr_bottom += pitch;
+ ptr_top -= pitch;
+ ++y_bottom;
+ --y_top;
+ }
+
+ ptr_top += x_pitch_sign;
+ ptr_bottom += x_pitch_sign;
+ x_top += x_pitch_sign;
+ x_bottom += x_pitch_sign;
+
+ interx += gradient;
+
+ switch (fill_m) {
+ case kFillDisabled:
+ if (IS_IN_CLIP(x_top, y_top)) *ptr_top = color;
+ if (IS_IN_CLIP(x_bottom, y_bottom)) *ptr_bottom = color;
+ break;
+ case kFillForeground:
+ case kFillBackground:
+ colorVFillClip<PixelType>(ptr_bottom + pitch, ptr_top, pitch, color, x_bottom, y_bottom + 1, _clippingArea);
+ blendPixelPtrClip(ptr_bottom, color, rfpart(interx), x_bottom, y_bottom);
+ blendPixelPtrClip(ptr_top, color, rfpart(interx), x_top, y_top);
+ break;
+ case kFillGradient:
+ colorVFillClip<PixelType>(ptr_bottom, ptr_top, pitch, calcGradient(gradient_w++, w), x_bottom, y_bottom, _clippingArea);
+ blendPixelPtrClip(ptr_bottom, color, rfpart(interx), x_bottom, y_bottom);
+ blendPixelPtrClip(ptr_top, color, rfpart(interx), x_top, y_top);
+ break;
+ default:
+ break;
+ }
+ }
+
+ return;
+ }
+
+#if FIXED_POINT
+ if (abs(dy) < abs(dx)) {
+#else
+ if (fabs(dy) < fabs(dx)) {
+#endif
+ ptr_top -= pitch;
+ --y_top;
+ while (floor != ptr_top) {
+ floor += pitch;
+ blendPixelPtrClip(floor, color, 50, x_floor, ++y_floor);
+ }
+
+#if FIXED_POINT
+ int gradient = (dy << 8) / (dx + 0x100);
+ int intery = (y1 << 8) + gradient;
+#else
+ double gradient = dy / (dx + 1);
+ double intery = y1 + gradient;
+#endif
+
+ for (int x = x1 + 1; x < x2; x++) {
+#if FIXED_POINT
+ if (intery + gradient >= ipart(intery) + 0x100) {
+#else
+ if (intery + gradient >= ipart(intery) + 1) {
+#endif
+ ptr_bottom += pitch;
+ ptr_top -= pitch;
+ ++y_bottom;
+ --y_top;
+ }
+
+ ptr_top += x_pitch_sign;
+ ptr_bottom += x_pitch_sign;
+ x_bottom += x_pitch_sign;
+ x_top += x_pitch_sign;
+
+ intery += gradient;
+
+ switch (fill_m) {
+ case kFillDisabled:
+ if (IS_IN_CLIP(x_top, y_top)) *ptr_top = color;
+ if (IS_IN_CLIP(x_bottom, y_bottom)) *ptr_bottom = color;
+ break;
+ case kFillForeground:
+ case kFillBackground:
+ colorVFillClip<PixelType>(ptr_bottom + pitch, ptr_top, pitch, color, x_bottom, y_bottom + 1, _clippingArea);
+ blendPixelPtrClip(ptr_bottom, color, rfpart(intery), x_bottom, y_bottom);
+ blendPixelPtrClip(ptr_top, color, rfpart(intery), x_top, y_top);
+ break;
+ case kFillGradient:
+ colorVFillClip<PixelType>(ptr_bottom, ptr_top, pitch, calcGradient(gradient_w++, w), x_bottom, y_bottom, _clippingArea);
+ blendPixelPtrClip(ptr_bottom, color, rfpart(intery), x_bottom, y_bottom);
+ blendPixelPtrClip(ptr_top, color, rfpart(intery), x_top, y_top);
+ break;
+ default:
+ break;
+ }
+ }
+
+ return;
+ }
+
+ ptr_top -= pitch;
+ --y_top;
+ while (floor != ptr_top) {
+ floor += pitch;
+ blendPixelPtrClip(floor, color, 50, x_floor, ++y_floor);
+ }
+
+#if FIXED_POINT
+ int gradient = (dy / dx) << 8;
+ int intery = (y1 << 8) + gradient;
+#else
+ double gradient = dy / dx;
+ double intery = y1 + gradient;
+#endif
+
+ for (int x = x1 + 1; x < x2; x++) {
+ ptr_bottom += pitch;
+ ptr_top -= pitch;
+ ++y_bottom;
+ --y_top;
+
+ ptr_top += x_pitch_sign;
+ ptr_bottom += x_pitch_sign;
+ x_bottom += x_pitch_sign;
+ x_top += x_pitch_sign;
+
+ intery += gradient;
+
+ switch (fill_m) {
+ case kFillDisabled:
+ if (IS_IN_CLIP(x_top, y_top)) *ptr_top = color;
+ if (IS_IN_CLIP(x_bottom, y_bottom)) *ptr_bottom = color;
+ break;
+ case kFillForeground:
+ case kFillBackground:
+ colorVFillClip<PixelType>(ptr_bottom + pitch, ptr_top, pitch, color, x_bottom, y_bottom + 1, _clippingArea);
+ blendPixelPtrClip(ptr_bottom, color, rfpart(intery), x_bottom, y_bottom);
+ blendPixelPtrClip(ptr_top, color, rfpart(intery), x_top, y_top);
+ break;
+ case kFillGradient:
+ colorVFillClip<PixelType>(ptr_bottom, ptr_top, pitch, calcGradient(gradient_w++, w), x_bottom, y_bottom, _clippingArea);
+ blendPixelPtrClip(ptr_bottom, color, rfpart(intery), x_bottom, y_bottom);
+ blendPixelPtrClip(ptr_top, color, rfpart(intery), x_top, y_top);
+ break;
+ default:
+ break;
+ }
+ }
+}
+
+/////////////
+
+/** HORIZONTAL TRIANGLE DRAWING - FAST VERSION FOR SQUARED TRIANGLES */
+template<typename PixelType>
+void VectorRendererSpec<PixelType>::
+drawTriangleFastH(int x1, int y1, int size, bool inverted, PixelType color, VectorRenderer::FillMode fill_m) {
+ // Do not draw anything for empty rects.
+ if (size <= 0) {
+ return;
+ }
+
+ int pitch = _activeSurface->pitch / _activeSurface->format.bytesPerPixel;
+ int x_pitch_sign = 1;
+
+ if (!inverted) {
+ y1 += size;
+ x_pitch_sign = -1;
+ }
+
+ int gradient_w = 0;
+ PixelType *ptr_bottom = (PixelType *)_activeSurface->getBasePtr(x1, y1);
+ PixelType *ptr_top = (PixelType *)_activeSurface->getBasePtr(x1, y1 + size);
+ int x2 = x1 + size;
+ int y2 = y1 + size / 2;
+ int deltaX = abs(x2 - x1);
+ int deltaY = abs(y2 - y1);
+ int signX = x1 < x2 ? 1 : -1;
+ int signY = y1 < y2 ? 1 : -1;
+ int error = deltaX - deltaY;
+
+ colorVFill<PixelType>(ptr_bottom, ptr_top, pitch, color);
+
+ while (1) {
+ switch (fill_m) {
+ case kFillDisabled:
+ *ptr_top = *ptr_bottom = color;
+ break;
+ case kFillForeground:
+ case kFillBackground:
+ colorVFill<PixelType>(ptr_bottom, ptr_top, pitch, color);
+ break;
+ case kFillGradient:
+ colorVFill<PixelType>(ptr_bottom, ptr_top, pitch, calcGradient(gradient_w++, size));
+ break;
+ default:
+ break;
+ }
+
+ if (x1 == x2 && y1 == y2)
+ break;
+
+ int error2 = error * 2;
+
+ if (error2 > -deltaX) {
+ error -= deltaX;
+ y1 += signY;
+ ptr_bottom += signY * pitch;
+ ptr_top += -signY * pitch;
+ }
+
+ if (error2 < deltaY) {
+ error += deltaY;
+ x1 += signX;
+ ptr_bottom += x_pitch_sign;
+ ptr_top += x_pitch_sign;
+ }
+ }
+}
+
template<typename PixelType>
void VectorRendererSpec<PixelType>::
drawTriangleVertAlg(int x1, int y1, int w, int h, bool inverted, PixelType color, VectorRenderer::FillMode fill_m) {
@@ -2548,7 +3051,7 @@ drawTriangleVertAlgClip(int x1, int y1, int w, int h, bool inverted, PixelType c
/** VERTICAL TRIANGLE DRAWING - FAST VERSION FOR SQUARED TRIANGLES */
template<typename PixelType>
void VectorRendererSpec<PixelType>::
-drawTriangleFast(int x1, int y1, int size, bool inverted, PixelType color, VectorRenderer::FillMode fill_m) {
+drawTriangleFastV(int x1, int y1, int size, bool inverted, PixelType color, VectorRenderer::FillMode fill_m) {
// Do not draw anything for empty rects.
if (size <= 0) {
return;
diff --git a/graphics/VectorRendererSpec.h b/graphics/VectorRendererSpec.h
index 4d29f467c8..aab95a6f16 100644
--- a/graphics/VectorRendererSpec.h
+++ b/graphics/VectorRendererSpec.h
@@ -203,13 +203,22 @@ protected:
virtual void drawSquareAlgClip(int x, int y, int w, int h,
PixelType color, FillMode fill_m);
+ virtual void drawTriangleHorzAlg(int x, int y, int w, int h,
+ bool inverted, PixelType color, FillMode fill_m);
+
+ virtual void drawTriangleHorzAlgClip(int x, int y, int w, int h,
+ bool inverted, PixelType color, FillMode fill_m);
+
+ virtual void drawTriangleFastH(int x, int y, int size,
+ bool inverted, PixelType color, FillMode fill_m);
+
virtual void drawTriangleVertAlg(int x, int y, int w, int h,
bool inverted, PixelType color, FillMode fill_m);
virtual void drawTriangleVertAlgClip(int x, int y, int w, int h,
bool inverted, PixelType color, FillMode fill_m);
- virtual void drawTriangleFast(int x, int y, int size,
+ virtual void drawTriangleFastV(int x, int y, int size,
bool inverted, PixelType color, FillMode fill_m);
virtual void drawBevelSquareAlg(int x, int y, int w, int h,
More information about the Scummvm-git-logs
mailing list