git_clone/thorvg
1
0
Fork 0
mirror of https://github.com/thorvg/thorvg.git synced 2025-07-06 06:35:01 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

sw_engine: keep the code in a more primitive style

Browse source
This commit is contained in:
Hermet Park 2025-07-03 15:06:24 +09:00 • committed by Hermet Park
parent ea8abe8912
commit f59da6a79f
5 changed files with 97 additions and 99 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

46
src/renderer/sw_engine/tvgSwCommon.h
View file

@ -34,17 +34,15 @@
#define SW_ANGLE_2PI (SW_ANGLE_PI << 1) #define SW_ANGLE_2PI (SW_ANGLE_PI << 1)
#define SW_ANGLE_PI2 (SW_ANGLE_PI >> 1) #define SW_ANGLE_PI2 (SW_ANGLE_PI >> 1)
using SwCoord = int32_t;
using SwFixed = int64_t;
static inline float TO_FLOAT(SwCoord val) static inline float TO_FLOAT(int32_t val)
{ {
return static_cast<float>(val) / 64.0f; return static_cast<float>(val) / 64.0f;
} }
struct SwPoint struct SwPoint
{ {
SwCoord x, y; int32_t x, y;
SwPoint& operator-=(const SwPoint& rhs) SwPoint& operator-=(const SwPoint& rhs)
{ {
@ -101,7 +99,7 @@ struct SwPoint
struct SwSize struct SwSize
{ {
SwCoord w, h; int32_t w, h;
}; };
struct SwOutline struct SwOutline
@ -203,15 +201,15 @@ struct SwStrokeBorder
struct SwStroke struct SwStroke
{ {
SwFixed angleIn; int64_t angleIn;
SwFixed angleOut; int64_t angleOut;
SwPoint center; SwPoint center;
SwFixed lineLength; int64_t lineLength;
SwFixed subPathAngle; int64_t subPathAngle;
SwPoint ptStartSubPath; SwPoint ptStartSubPath;
SwFixed subPathLineLength; int64_t subPathLineLength;
SwFixed width; int64_t width;
SwFixed miterlimit; int64_t miterlimit;
SwFill* fill = nullptr; SwFill* fill = nullptr;
SwStrokeBorder borders[2]; SwStrokeBorder borders[2];
float sx, sy; float sx, sy;
@ -319,9 +317,9 @@ struct SwMpool
unsigned allocSize; unsigned allocSize;
}; };
static inline SwCoord TO_SWCOORD(float val) static inline int32_t TO_SWCOORD(float val)
{ {
return SwCoord(val * 64.0f); return int32_t(val * 64.0f);
} }
static inline uint32_t JOIN(uint8_t c0, uint8_t c1, uint8_t c2, uint8_t c3) static inline uint32_t JOIN(uint8_t c0, uint8_t c1, uint8_t c2, uint8_t c3)
@ -345,7 +343,7 @@ static inline uint8_t INTERPOLATE8(uint8_t s, uint8_t d, uint8_t a)
return (((s) * (a) + 0xff) >> 8) + (((d) * ~(a) + 0xff) >> 8); return (((s) * (a) + 0xff) >> 8) + (((d) * ~(a) + 0xff) >> 8);
} }
static inline SwCoord HALF_STROKE(float width) static inline int32_t HALF_STROKE(float width)
{ {
return TO_SWCOORD(width * 0.5f); return TO_SWCOORD(width * 0.5f);
} }
@ -515,17 +513,17 @@ static inline uint32_t opBlendSoftLight(uint32_t s, uint32_t d, TVG_UNUSED uint8
int64_t mathMultiply(int64_t a, int64_t b); int64_t mathMultiply(int64_t a, int64_t b);
int64_t mathDivide(int64_t a, int64_t b); int64_t mathDivide(int64_t a, int64_t b);
int64_t mathMulDiv(int64_t a, int64_t b, int64_t c); int64_t mathMulDiv(int64_t a, int64_t b, int64_t c);
void mathRotate(SwPoint& pt, SwFixed angle); void mathRotate(SwPoint& pt, int64_t angle);
SwFixed mathTan(SwFixed angle); int64_t mathTan(int64_t angle);
SwFixed mathAtan(const SwPoint& pt); int64_t mathAtan(const SwPoint& pt);
SwFixed mathCos(SwFixed angle); int64_t mathCos(int64_t angle);
SwFixed mathSin(SwFixed angle); int64_t mathSin(int64_t angle);
void mathSplitCubic(SwPoint* base); void mathSplitCubic(SwPoint* base);
void mathSplitLine(SwPoint* base); void mathSplitLine(SwPoint* base);
SwFixed mathDiff(SwFixed angle1, SwFixed angle2); int64_t mathDiff(int64_t angle1, int64_t angle2);
SwFixed mathLength(const SwPoint& pt); int64_t mathLength(const SwPoint& pt);
int mathCubicAngle(const SwPoint* base, SwFixed& angleIn, SwFixed& angleMid, SwFixed& angleOut); int mathCubicAngle(const SwPoint* base, int64_t& angleIn, int64_t& angleMid, int64_t& angleOut);
SwFixed mathMean(SwFixed angle1, SwFixed angle2); int64_t mathMean(int64_t angle1, int64_t angle2);
SwPoint mathTransform(const Point* to, const Matrix& transform); SwPoint mathTransform(const Point* to, const Matrix& transform);
bool mathUpdateOutlineBBox(const SwOutline* outline, const RenderRegion& clipBox, RenderRegion& renderBox, bool fastTrack); bool mathUpdateOutlineBBox(const SwOutline* outline, const RenderRegion& clipBox, RenderRegion& renderBox, bool fastTrack);

36
src/renderer/sw_engine/tvgSwMath.cpp
View file

@ -28,7 +28,7 @@
/* Internal Class Implementation */ /* Internal Class Implementation */
/************************************************************************/ /************************************************************************/
static float TO_RADIAN(SwFixed angle) static float TO_RADIAN(int64_t angle)
{ {
return (float(angle) / 65536.0f) * (MATH_PI / 180.0f); return (float(angle) / 65536.0f) * (MATH_PI / 180.0f);
} }
@ -38,13 +38,13 @@ static float TO_RADIAN(SwFixed angle)
/* External Class Implementation */ /* External Class Implementation */
/************************************************************************/ /************************************************************************/
SwFixed mathMean(SwFixed angle1, SwFixed angle2) int64_t mathMean(int64_t angle1, int64_t angle2)
{ {
return angle1 + mathDiff(angle1, angle2) / 2; return angle1 + mathDiff(angle1, angle2) / 2;
} }
int mathCubicAngle(const SwPoint* base, SwFixed& angleIn, SwFixed& angleMid, SwFixed& angleOut) int mathCubicAngle(const SwPoint* base, int64_t& angleIn, int64_t& angleMid, int64_t& angleOut)
{ {
auto d1 = base[2] - base[3]; auto d1 = base[2] - base[3];
auto d2 = base[1] - base[2]; auto d2 = base[1] - base[2];
@ -154,7 +154,7 @@ int64_t mathMulDiv(int64_t a, int64_t b, int64_t c)
} }
void mathRotate(SwPoint& pt, SwFixed angle) void mathRotate(SwPoint& pt, int64_t angle)
{ {
if (angle == 0 || pt.zero()) return; if (angle == 0 || pt.zero()) return;
@ -164,39 +164,39 @@ void mathRotate(SwPoint& pt, SwFixed angle)
auto cosv = cosf(radian); auto cosv = cosf(radian);
auto sinv = sinf(radian); auto sinv = sinf(radian);
pt.x = SwCoord(nearbyint((v.x * cosv - v.y * sinv) * 64.0f)); pt.x = int32_t(nearbyint((v.x * cosv - v.y * sinv) * 64.0f));
pt.y = SwCoord(nearbyint((v.x * sinv + v.y * cosv) * 64.0f)); pt.y = int32_t(nearbyint((v.x * sinv + v.y * cosv) * 64.0f));
} }
SwFixed mathTan(SwFixed angle) int64_t mathTan(int64_t angle)
{ {
if (angle == 0) return 0; if (angle == 0) return 0;
return SwFixed(tanf(TO_RADIAN(angle)) * 65536.0f); return int64_t(tanf(TO_RADIAN(angle)) * 65536.0f);
} }
SwFixed mathAtan(const SwPoint& pt) int64_t mathAtan(const SwPoint& pt)
{ {
if (pt.zero()) return 0; if (pt.zero()) return 0;
return SwFixed(tvg::atan2(TO_FLOAT(pt.y), TO_FLOAT(pt.x)) * (180.0f / MATH_PI) * 65536.0f); return int64_t(tvg::atan2(TO_FLOAT(pt.y), TO_FLOAT(pt.x)) * (180.0f / MATH_PI) * 65536.0f);
} }
SwFixed mathSin(SwFixed angle) int64_t mathSin(int64_t angle)
{ {
if (angle == 0) return 0; if (angle == 0) return 0;
return mathCos(SW_ANGLE_PI2 - angle); return mathCos(SW_ANGLE_PI2 - angle);
} }
SwFixed mathCos(SwFixed angle) int64_t mathCos(int64_t angle)
{ {
return SwFixed(cosf(TO_RADIAN(angle)) * 65536.0f); return int64_t(cosf(TO_RADIAN(angle)) * 65536.0f);
} }
SwFixed mathLength(const SwPoint& pt) int64_t mathLength(const SwPoint& pt)
{ {
if (pt.zero()) return 0; if (pt.zero()) return 0;
@ -205,20 +205,20 @@ SwFixed mathLength(const SwPoint& pt)
if (pt.y == 0) return abs(pt.x); if (pt.y == 0) return abs(pt.x);
auto v = pt.toPoint(); auto v = pt.toPoint();
//return static_cast<SwFixed>(sqrtf(v.x * v.x + v.y * v.y) * 65536.0f); //return static_cast<int64_t>(sqrtf(v.x * v.x + v.y * v.y) * 65536.0f);
/* approximate sqrt(x*x + y*y) using alpha max plus beta min algorithm. /* approximate sqrt(x*x + y*y) using alpha max plus beta min algorithm.
With alpha = 1, beta = 3/8, giving results with the largest error less With alpha = 1, beta = 3/8, giving results with the largest error less
than 7% compared to the exact value. */ than 7% compared to the exact value. */
if (v.x < 0) v.x = -v.x; if (v.x < 0) v.x = -v.x;
if (v.y < 0) v.y = -v.y; if (v.y < 0) v.y = -v.y;
return static_cast<SwFixed>((v.x > v.y) ? (v.x + v.y * 0.375f) : (v.y + v.x * 0.375f)); return static_cast<int64_t>((v.x > v.y) ? (v.x + v.y * 0.375f) : (v.y + v.x * 0.375f));
} }
void mathSplitCubic(SwPoint* base) void mathSplitCubic(SwPoint* base)
{ {
SwCoord a, b, c, d; int32_t a, b, c, d;
base[6].x = base[3].x; base[6].x = base[3].x;
c = base[1].x; c = base[1].x;
@ -250,7 +250,7 @@ void mathSplitLine(SwPoint* base)
} }
SwFixed mathDiff(SwFixed angle1, SwFixed angle2) int64_t mathDiff(int64_t angle1, int64_t angle2)
{ {
auto delta = angle2 - angle1; auto delta = angle2 - angle1;

2
src/renderer/sw_engine/tvgSwPostEffect.cpp
View file

@ -330,7 +330,7 @@ void effectDropShadowUpdate(RenderEffectDropShadow* params, const Matrix& transf
//offset //offset
if (params->distance > 0.0f) { if (params->distance > 0.0f) {
auto radian = tvg::deg2rad(90.0f - params->angle); auto radian = tvg::deg2rad(90.0f - params->angle);
rd->offset = {(SwCoord)(params->distance * cosf(radian)), (SwCoord)(-1.0f * params->distance * sinf(radian))}; rd->offset = {(int32_t)(params->distance * cosf(radian)), (int32_t)(-1.0f * params->distance * sinf(radian))};
} else { } else {
rd->offset = {0, 0}; rd->offset = {0, 0};
} }

32
src/renderer/sw_engine/tvgSwRle.cpp
View file

@ -202,13 +202,13 @@ using Area = long;
struct Band struct Band
{ {
SwCoord min, max; int32_t min, max;
}; };
struct Cell struct Cell
{ {
SwCoord x; int32_t x;
SwCoord cover; int32_t cover;
Area area; Area area;
Cell *next; Cell *next;
}; };
@ -220,11 +220,11 @@ struct RleWorker
SwPoint cellPos; SwPoint cellPos;
SwPoint cellMin; SwPoint cellMin;
SwPoint cellMax; SwPoint cellMax;
SwCoord cellXCnt; int32_t cellXCnt;
SwCoord cellYCnt; int32_t cellYCnt;
Area area; Area area;
SwCoord cover; int32_t cover;
Cell* cells; Cell* cells;
ptrdiff_t maxCells; ptrdiff_t maxCells;
@ -245,7 +245,7 @@ struct RleWorker
long bufferSize; long bufferSize;
Cell** yCells; Cell** yCells;
SwCoord yCnt; int32_t yCnt;
bool invalid; bool invalid;
bool antiAlias; bool antiAlias;
@ -254,11 +254,11 @@ struct RleWorker
static inline SwPoint UPSCALE(const SwPoint& pt) static inline SwPoint UPSCALE(const SwPoint& pt)
{ {
return {SwCoord(((unsigned long) pt.x) << (PIXEL_BITS - 6)), SwCoord(((unsigned long) pt.y) << (PIXEL_BITS - 6))}; return {int32_t(((unsigned long) pt.x) << (PIXEL_BITS - 6)), int32_t(((unsigned long) pt.y) << (PIXEL_BITS - 6))};
} }
static inline SwCoord TRUNC(const SwCoord x) static inline int32_t TRUNC(const int32_t x)
{ {
return x >> PIXEL_BITS; return x >> PIXEL_BITS;
} }
@ -282,7 +282,7 @@ static inline SwPoint FRACT(const SwPoint& pt)
* algorithm. We use alpha = 1, beta = 3/8, giving us results with a * algorithm. We use alpha = 1, beta = 3/8, giving us results with a
* largest error less than 7% compared to the exact value. * largest error less than 7% compared to the exact value.
*/ */
static inline SwCoord HYPOT(SwPoint pt) static inline int32_t HYPOT(SwPoint pt)
{ {
if (pt.x < 0) pt.x = -pt.x; if (pt.x < 0) pt.x = -pt.x;
if (pt.y < 0) pt.y = -pt.y; if (pt.y < 0) pt.y = -pt.y;
@ -290,7 +290,7 @@ static inline SwCoord HYPOT(SwPoint pt)
} }
static void _horizLine(RleWorker& rw, SwCoord x, SwCoord y, SwCoord area, SwCoord aCount) static void _horizLine(RleWorker& rw, int32_t x, int32_t y, int32_t area, int32_t aCount)
{ {
x += rw.cellMin.x; x += rw.cellMin.x;
y += rw.cellMin.y; y += rw.cellMin.y;
@ -328,7 +328,7 @@ static void _horizLine(RleWorker& rw, SwCoord x, SwCoord y, SwCoord area, SwCoor
auto& span = rle->spans.last(); auto& span = rle->spans.last();
if ((span.coverage == coverage) && (span.y == y) && (span.x + span.len == x)) { if ((span.coverage == coverage) && (span.y == y) && (span.x + span.len == x)) {
//Clip x range //Clip x range
SwCoord xOver = 0; int32_t xOver = 0;
if (x + aCount >= rw.cellMax.x) xOver -= (x + aCount - rw.cellMax.x); if (x + aCount >= rw.cellMax.x) xOver -= (x + aCount - rw.cellMax.x);
if (x < rw.cellMin.x) xOver -= (rw.cellMin.x - x); if (x < rw.cellMin.x) xOver -= (rw.cellMin.x - x);
span.len += (aCount + xOver); span.len += (aCount + xOver);
@ -337,7 +337,7 @@ static void _horizLine(RleWorker& rw, SwCoord x, SwCoord y, SwCoord area, SwCoor
} }
//Clip x range //Clip x range
SwCoord xOver = 0; int32_t xOver = 0;
if (x + aCount >= rw.cellMax.x) xOver -= (x + aCount - rw.cellMax.x); if (x + aCount >= rw.cellMax.x) xOver -= (x + aCount - rw.cellMax.x);
if (x < rw.cellMin.x) { if (x < rw.cellMin.x) {
xOver -= (rw.cellMin.x - x); xOver -= (rw.cellMin.x - x);
@ -537,7 +537,7 @@ static bool _lineTo(RleWorker& rw, const SwPoint& to)
} }
//any other line //any other line
} else { } else {
#define SW_UDIV(a, b) (SwCoord)((uint64_t(a) * uint64_t(b)) >> 32) #define SW_UDIV(a, b) (int32_t)((uint64_t(a) * uint64_t(b)) >> 32)
Area prod = diff.x * f1.y - diff.y * f1.x; Area prod = diff.x * f1.y - diff.y * f1.x;
@ -614,7 +614,7 @@ static bool _cubicTo(RleWorker& rw, const SwPoint& ctrl1, const SwPoint& ctrl2,
auto min = arc[0].y; auto min = arc[0].y;
auto max = arc[0].y; auto max = arc[0].y;
SwCoord y; int32_t y;
for (auto i = 1; i < 4; ++i) { for (auto i = 1; i < 4; ++i) {
y = arc[i].y; y = arc[i].y;
if (y < min) min = y; if (y < min) min = y;
@ -772,7 +772,7 @@ SwRle* rleRender(SwRle* rle, const SwOutline* outline, const RenderRegion& bbox,
auto min = rw.cellMin.y; auto min = rw.cellMin.y;
auto yMax = rw.cellMax.y; auto yMax = rw.cellMax.y;
SwCoord max; int32_t max;
for (int n = 0; n < bandCnt; ++n, min = max) { for (int n = 0; n < bandCnt; ++n, min = max) {
max = min + rw.bandSize; max = min + rw.bandSize;

80
src/renderer/sw_engine/tvgSwStroke.cpp
View file

@ -31,16 +31,16 @@ static constexpr auto SW_STROKE_TAG_CUBIC = 2;
static constexpr auto SW_STROKE_TAG_BEGIN = 4; static constexpr auto SW_STROKE_TAG_BEGIN = 4;
static constexpr auto SW_STROKE_TAG_END = 8; static constexpr auto SW_STROKE_TAG_END = 8;
static inline SwFixed SIDE_TO_ROTATE(const int32_t s) static inline int64_t SIDE_TO_ROTATE(const int32_t s)
{ {
return (SW_ANGLE_PI2 - static_cast<SwFixed>(s) * SW_ANGLE_PI); return (SW_ANGLE_PI2 - static_cast<int64_t>(s) * SW_ANGLE_PI);
} }
static inline void SCALE(const SwStroke& stroke, SwPoint& pt) static inline void SCALE(const SwStroke& stroke, SwPoint& pt)
{ {
pt.x = static_cast<SwCoord>(pt.x * stroke.sx); pt.x = static_cast<int32_t>(pt.x * stroke.sx);
pt.y = static_cast<SwCoord>(pt.y * stroke.sy); pt.y = static_cast<int32_t>(pt.y * stroke.sy);
} }
@ -131,10 +131,10 @@ static void _borderCubicTo(SwStrokeBorder* border, const SwPoint& ctrl1, const S
} }
static void _borderArcTo(SwStrokeBorder* border, const SwPoint& center, SwFixed radius, SwFixed angleStart, SwFixed angleDiff, SwStroke& stroke) static void _borderArcTo(SwStrokeBorder* border, const SwPoint& center, int64_t radius, int64_t angleStart, int64_t angleDiff, SwStroke& stroke)
{ {
constexpr SwFixed ARC_CUBIC_ANGLE = SW_ANGLE_PI / 2; constexpr int64_t ARC_CUBIC_ANGLE = SW_ANGLE_PI / 2;
SwPoint a = {static_cast<SwCoord>(radius), 0}; SwPoint a = {static_cast<int32_t>(radius), 0};
mathRotate(a, angleStart); mathRotate(a, angleStart);
SCALE(stroke, a); SCALE(stroke, a);
a += center; a += center;
@ -155,7 +155,7 @@ static void _borderArcTo(SwStrokeBorder* border, const SwPoint& center, SwFixed
theta >>= 1; theta >>= 1;
//compute end point //compute end point
SwPoint b = {static_cast<SwCoord>(radius), 0}; SwPoint b = {static_cast<int32_t>(radius), 0};
mathRotate(b, next); mathRotate(b, next);
SCALE(stroke, b); SCALE(stroke, b);
b += center; b += center;
@ -163,12 +163,12 @@ static void _borderArcTo(SwStrokeBorder* border, const SwPoint& center, SwFixed
//compute first and second control points //compute first and second control points
auto length = mathMulDiv(radius, mathSin(theta) * 4, (0x10000L + mathCos(theta)) * 3); auto length = mathMulDiv(radius, mathSin(theta) * 4, (0x10000L + mathCos(theta)) * 3);
SwPoint a2 = {static_cast<SwCoord>(length), 0}; SwPoint a2 = {static_cast<int32_t>(length), 0};
mathRotate(a2, angle + rotate); mathRotate(a2, angle + rotate);
SCALE(stroke, a2); SCALE(stroke, a2);
a2 += a; a2 += a;
SwPoint b2 = {static_cast<SwCoord>(length), 0}; SwPoint b2 = {static_cast<int32_t>(length), 0};
mathRotate(b2, next - rotate); mathRotate(b2, next - rotate);
SCALE(stroke, b2); SCALE(stroke, b2);
b2 += b; b2 += b;
@ -227,7 +227,7 @@ static void _arcTo(SwStroke& stroke, int32_t side)
} }
static void _outside(SwStroke& stroke, int32_t side, SwFixed lineLength) static void _outside(SwStroke& stroke, int32_t side, int64_t lineLength)
{ {
auto border = stroke.borders + side; auto border = stroke.borders + side;
@ -237,8 +237,8 @@ static void _outside(SwStroke& stroke, int32_t side, SwFixed lineLength)
//this is a mitered (pointed) or beveled (truncated) corner //this is a mitered (pointed) or beveled (truncated) corner
auto rotate = SIDE_TO_ROTATE(side); auto rotate = SIDE_TO_ROTATE(side);
auto bevel = stroke.join == StrokeJoin::Bevel; auto bevel = stroke.join == StrokeJoin::Bevel;
SwFixed phi = 0; int64_t phi = 0;
SwFixed thcos = 0; int64_t thcos = 0;
if (!bevel) { if (!bevel) {
auto theta = mathDiff(stroke.angleIn, stroke.angleOut); auto theta = mathDiff(stroke.angleIn, stroke.angleOut);
@ -259,7 +259,7 @@ static void _outside(SwStroke& stroke, int32_t side, SwFixed lineLength)
//this is a bevel (broken angle) //this is a bevel (broken angle)
if (bevel) { if (bevel) {
SwPoint delta = {static_cast<SwCoord>(stroke.width), 0}; SwPoint delta = {static_cast<int32_t>(stroke.width), 0};
mathRotate(delta, stroke.angleOut + rotate); mathRotate(delta, stroke.angleOut + rotate);
SCALE(stroke, delta); SCALE(stroke, delta);
delta += stroke.center; delta += stroke.center;
@ -268,7 +268,7 @@ static void _outside(SwStroke& stroke, int32_t side, SwFixed lineLength)
//this is a miter (intersection) //this is a miter (intersection)
} else { } else {
auto length = mathDivide(stroke.width, thcos); auto length = mathDivide(stroke.width, thcos);
SwPoint delta = {static_cast<SwCoord>(length), 0}; SwPoint delta = {static_cast<int32_t>(length), 0};
mathRotate(delta, phi); mathRotate(delta, phi);
SCALE(stroke, delta); SCALE(stroke, delta);
delta += stroke.center; delta += stroke.center;
@ -277,7 +277,7 @@ static void _outside(SwStroke& stroke, int32_t side, SwFixed lineLength)
/* Now add and end point /* Now add and end point
Only needed if not lineto (lineLength is zero for curves) */ Only needed if not lineto (lineLength is zero for curves) */
if (lineLength == 0) { if (lineLength == 0) {
delta = {static_cast<SwCoord>(stroke.width), 0}; delta = {static_cast<int32_t>(stroke.width), 0};
mathRotate(delta, stroke.angleOut + rotate); mathRotate(delta, stroke.angleOut + rotate);
SCALE(stroke, delta); SCALE(stroke, delta);
delta += stroke.center; delta += stroke.center;
@ -288,7 +288,7 @@ static void _outside(SwStroke& stroke, int32_t side, SwFixed lineLength)
} }
static void _inside(SwStroke& stroke, int32_t side, SwFixed lineLength) static void _inside(SwStroke& stroke, int32_t side, int64_t lineLength)
{ {
auto border = stroke.borders + side; auto border = stroke.borders + side;
auto theta = mathDiff(stroke.angleIn, stroke.angleOut) / 2; auto theta = mathDiff(stroke.angleIn, stroke.angleOut) / 2;
@ -299,14 +299,14 @@ static void _inside(SwStroke& stroke, int32_t side, SwFixed lineLength)
lines are long enough (line length is zero for curves). */ lines are long enough (line length is zero for curves). */
if (border->movable && lineLength > 0) { if (border->movable && lineLength > 0) {
//compute minimum required length of lines //compute minimum required length of lines
SwFixed minLength = abs(mathMultiply(stroke.width, mathTan(theta))); int64_t minLength = abs(mathMultiply(stroke.width, mathTan(theta)));
if (stroke.lineLength >= minLength && lineLength >= minLength) intersect = true; if (stroke.lineLength >= minLength && lineLength >= minLength) intersect = true;
} }
auto rotate = SIDE_TO_ROTATE(side); auto rotate = SIDE_TO_ROTATE(side);
if (!intersect) { if (!intersect) {
delta = {static_cast<SwCoord>(stroke.width), 0}; delta = {static_cast<int32_t>(stroke.width), 0};
mathRotate(delta, stroke.angleOut + rotate); mathRotate(delta, stroke.angleOut + rotate);
SCALE(stroke, delta); SCALE(stroke, delta);
delta += stroke.center; delta += stroke.center;
@ -315,7 +315,7 @@ static void _inside(SwStroke& stroke, int32_t side, SwFixed lineLength)
//compute median angle //compute median angle
auto phi = stroke.angleIn + theta; auto phi = stroke.angleIn + theta;
auto thcos = mathCos(theta); auto thcos = mathCos(theta);
delta = {static_cast<SwCoord>(mathDivide(stroke.width, thcos)), 0}; delta = {static_cast<int32_t>(mathDivide(stroke.width, thcos)), 0};
mathRotate(delta, phi + rotate); mathRotate(delta, phi + rotate);
SCALE(stroke, delta); SCALE(stroke, delta);
delta += stroke.center; delta += stroke.center;
@ -325,7 +325,7 @@ static void _inside(SwStroke& stroke, int32_t side, SwFixed lineLength)
} }
void _processCorner(SwStroke& stroke, SwFixed lineLength) void _processCorner(SwStroke& stroke, int64_t lineLength)
{ {
auto turn = mathDiff(stroke.angleIn, stroke.angleOut); auto turn = mathDiff(stroke.angleIn, stroke.angleOut);
@ -346,9 +346,9 @@ void _processCorner(SwStroke& stroke, SwFixed lineLength)
} }
void _firstSubPath(SwStroke& stroke, SwFixed startAngle, SwFixed lineLength) void _firstSubPath(SwStroke& stroke, int64_t startAngle, int64_t lineLength)
{ {
SwPoint delta = {static_cast<SwCoord>(stroke.width), 0}; SwPoint delta = {static_cast<int32_t>(stroke.width), 0};
mathRotate(delta, startAngle + SW_ANGLE_PI2); mathRotate(delta, startAngle + SW_ANGLE_PI2);
SCALE(stroke, delta); SCALE(stroke, delta);
@ -383,12 +383,12 @@ static void _lineTo(SwStroke& stroke, const SwPoint& to)
The scale needs to be reverted since the stroke width has not been scaled. The scale needs to be reverted since the stroke width has not been scaled.
An alternative option is to scale the width of the stroke properly by An alternative option is to scale the width of the stroke properly by
calculating the mixture of the sx/sy rating on the stroke direction. */ calculating the mixture of the sx/sy rating on the stroke direction. */
delta.x = static_cast<SwCoord>(delta.x / stroke.sx); delta.x = static_cast<int32_t>(delta.x / stroke.sx);
delta.y = static_cast<SwCoord>(delta.y / stroke.sy); delta.y = static_cast<int32_t>(delta.y / stroke.sy);
auto lineLength = mathLength(delta); auto lineLength = mathLength(delta);
auto angle = mathAtan(delta); auto angle = mathAtan(delta);
delta = {static_cast<SwCoord>(stroke.width), 0}; delta = {static_cast<int32_t>(stroke.width), 0};
mathRotate(delta, angle + SW_ANGLE_PI2); mathRotate(delta, angle + SW_ANGLE_PI2);
SCALE(stroke, delta); SCALE(stroke, delta);
@ -438,7 +438,7 @@ static void _cubicTo(SwStroke& stroke, const SwPoint& ctrl1, const SwPoint& ctrl
arc[3] = stroke.center; arc[3] = stroke.center;
while (arc >= bezStack) { while (arc >= bezStack) {
SwFixed angleIn, angleOut, angleMid; int64_t angleIn, angleOut, angleMid;
//initialize with current direction //initialize with current direction
angleIn = angleOut = angleMid = stroke.angleIn; angleIn = angleOut = angleMid = stroke.angleIn;
@ -491,7 +491,7 @@ static void _cubicTo(SwStroke& stroke, const SwPoint& ctrl1, const SwPoint& ctrl
auto phi2 = mathMean(angleMid, angleOut); auto phi2 = mathMean(angleMid, angleOut);
auto length1 = mathDivide(stroke.width, mathCos(theta1)); auto length1 = mathDivide(stroke.width, mathCos(theta1));
auto length2 = mathDivide(stroke.width, mathCos(theta2)); auto length2 = mathDivide(stroke.width, mathCos(theta2));
SwFixed alpha0 = 0; int64_t alpha0 = 0;
//compute direction of original arc //compute direction of original arc
if (stroke.handleWideStrokes) { if (stroke.handleWideStrokes) {
@ -505,18 +505,18 @@ static void _cubicTo(SwStroke& stroke, const SwPoint& ctrl1, const SwPoint& ctrl
auto rotate = SIDE_TO_ROTATE(side); auto rotate = SIDE_TO_ROTATE(side);
//compute control points //compute control points
SwPoint _ctrl1 = {static_cast<SwCoord>(length1), 0}; SwPoint _ctrl1 = {static_cast<int32_t>(length1), 0};
mathRotate(_ctrl1, phi1 + rotate); mathRotate(_ctrl1, phi1 + rotate);
SCALE(stroke, _ctrl1); SCALE(stroke, _ctrl1);
_ctrl1 += arc[2]; _ctrl1 += arc[2];
SwPoint _ctrl2 = {static_cast<SwCoord>(length2), 0}; SwPoint _ctrl2 = {static_cast<int32_t>(length2), 0};
mathRotate(_ctrl2, phi2 + rotate); mathRotate(_ctrl2, phi2 + rotate);
SCALE(stroke, _ctrl2); SCALE(stroke, _ctrl2);
_ctrl2 += arc[1]; _ctrl2 += arc[1];
//compute end point //compute end point
SwPoint _end = {static_cast<SwCoord>(stroke.width), 0}; SwPoint _end = {static_cast<int32_t>(stroke.width), 0};
mathRotate(_end, angleOut + rotate); mathRotate(_end, angleOut + rotate);
SCALE(stroke, _end); SCALE(stroke, _end);
_end += arc[0]; _end += arc[0];
@ -539,7 +539,7 @@ static void _cubicTo(SwStroke& stroke, const SwPoint& ctrl1, const SwPoint& ctrl
auto sinB = abs(mathSin(beta - gamma)); auto sinB = abs(mathSin(beta - gamma));
auto alen = mathMulDiv(blen, sinA, sinB); auto alen = mathMulDiv(blen, sinA, sinB);
SwPoint delta = {static_cast<SwCoord>(alen), 0}; SwPoint delta = {static_cast<int32_t>(alen), 0};
mathRotate(delta, beta); mathRotate(delta, beta);
delta += _start; delta += _start;
@ -568,28 +568,28 @@ static void _cubicTo(SwStroke& stroke, const SwPoint& ctrl1, const SwPoint& ctrl
} }
static void _addCap(SwStroke& stroke, SwFixed angle, int32_t side) static void _addCap(SwStroke& stroke, int64_t angle, int32_t side)
{ {
if (stroke.cap == StrokeCap::Square) { if (stroke.cap == StrokeCap::Square) {
auto rotate = SIDE_TO_ROTATE(side); auto rotate = SIDE_TO_ROTATE(side);
auto border = stroke.borders + side; auto border = stroke.borders + side;
SwPoint delta = {static_cast<SwCoord>(stroke.width), 0}; SwPoint delta = {static_cast<int32_t>(stroke.width), 0};
mathRotate(delta, angle); mathRotate(delta, angle);
SCALE(stroke, delta); SCALE(stroke, delta);
SwPoint delta2 = {static_cast<SwCoord>(stroke.width), 0}; SwPoint delta2 = {static_cast<int32_t>(stroke.width), 0};
mathRotate(delta2, angle + rotate); mathRotate(delta2, angle + rotate);
SCALE(stroke, delta2); SCALE(stroke, delta2);
delta += stroke.center + delta2; delta += stroke.center + delta2;
_borderLineTo(border, delta, false); _borderLineTo(border, delta, false);
delta = {static_cast<SwCoord>(stroke.width), 0}; delta = {static_cast<int32_t>(stroke.width), 0};
mathRotate(delta, angle); mathRotate(delta, angle);
SCALE(stroke, delta); SCALE(stroke, delta);
delta2 = {static_cast<SwCoord>(stroke.width), 0}; delta2 = {static_cast<int32_t>(stroke.width), 0};
mathRotate(delta2, angle - rotate); mathRotate(delta2, angle - rotate);
SCALE(stroke, delta2); SCALE(stroke, delta2);
delta += delta2 + stroke.center; delta += delta2 + stroke.center;
@ -603,14 +603,14 @@ static void _addCap(SwStroke& stroke, SwFixed angle, int32_t side)
auto rotate = SIDE_TO_ROTATE(side); auto rotate = SIDE_TO_ROTATE(side);
auto border = stroke.borders + side; auto border = stroke.borders + side;
SwPoint delta = {static_cast<SwCoord>(stroke.width), 0}; SwPoint delta = {static_cast<int32_t>(stroke.width), 0};
mathRotate(delta, angle + rotate); mathRotate(delta, angle + rotate);
SCALE(stroke, delta); SCALE(stroke, delta);
delta += stroke.center; delta += stroke.center;
_borderLineTo(border, delta, false); _borderLineTo(border, delta, false);
delta = {static_cast<SwCoord>(stroke.width), 0}; delta = {static_cast<int32_t>(stroke.width), 0};
mathRotate(delta, angle - rotate); mathRotate(delta, angle - rotate);
SCALE(stroke, delta); SCALE(stroke, delta);
delta += stroke.center; delta += stroke.center;
@ -822,7 +822,7 @@ void strokeReset(SwStroke* stroke, const RenderShape* rshape, const Matrix& tran
stroke->sy = sqrtf(powf(transform.e12, 2.0f) + powf(transform.e22, 2.0f)); stroke->sy = sqrtf(powf(transform.e12, 2.0f) + powf(transform.e22, 2.0f));
stroke->width = HALF_STROKE(rshape->strokeWidth()); stroke->width = HALF_STROKE(rshape->strokeWidth());
stroke->cap = rshape->strokeCap(); stroke->cap = rshape->strokeCap();
stroke->miterlimit = static_cast<SwFixed>(rshape->strokeMiterlimit() * 65536.0f); stroke->miterlimit = static_cast<int64_t>(rshape->strokeMiterlimit() * 65536.0f);
//Save line join: it can be temporarily changed when stroking curves... //Save line join: it can be temporarily changed when stroking curves...
stroke->joinSaved = stroke->join = rshape->strokeJoin(); stroke->joinSaved = stroke->join = rshape->strokeJoin();