introduce common math functions to improve the reusability.
'tvgLoader.h',
'tvgLoadModule.h',
'tvgLzw.h',
+ 'tvgMath.h',
'tvgPictureImpl.h',
'tvgRender.h',
'tvgIteratorAccessor.h',
SwFixed mathMean(SwFixed angle1, SwFixed angle2);
SwPoint mathTransform(const Point* to, const Matrix* transform);
bool mathUpdateOutlineBBox(const SwOutline* outline, const SwBBox& clipRegion, SwBBox& renderRegion, bool fastTrack);
-bool mathInverse(const Matrix* m, Matrix* invM);
-bool mathMultiply(const Matrix* lhs, Matrix* rhs);
-bool mathIdentity(const Matrix* m);
void shapeReset(SwShape* shape);
bool shapePrepare(SwShape* shape, const Shape* sdata, const Matrix* transform, const SwBBox& clipRegion, SwBBox& renderRegion, SwMpool* mpool, unsigned tid, bool hasComposite);
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
-#include <float.h>
-#include <math.h>
+#include "tvgMath.h"
#include "tvgSwCommon.h"
fill->linear.offset = -fill->linear.dx * x1 - fill->linear.dy * y1;
auto gradTransform = linear->transform();
- bool isTransformation = !mathIdentity(&gradTransform);
+ bool isTransformation = !mathIdentity((const Matrix*)(&gradTransform));
if (isTransformation) {
- if (transform) mathMultiply(transform, &gradTransform);
+ if (transform) gradTransform = mathMultiply(transform, &gradTransform);
} else if (transform) {
gradTransform = *transform;
isTransformation = true;
fill->radial.a = radius;
auto gradTransform = radial->transform();
- bool isTransformation = !mathIdentity(&gradTransform);
+ bool isTransformation = !mathIdentity((const Matrix*)(&gradTransform));
if (isTransformation) {
- if (transform) mathMultiply(transform, &gradTransform);
+ if (transform) gradTransform = mathMultiply(transform, &gradTransform);
} else if (transform) {
gradTransform = *transform;
isTransformation = true;
* SOFTWARE.
*/
#include <math.h>
-#include <float.h>
#include "tvgSwCommon.h"
renderRegion.max.x <= clipRegion.min.x || renderRegion.max.y <= clipRegion.min.y) return false;
return true;
-}
-
-
-bool mathInverse(const Matrix* m, Matrix* invM)
-{
- auto det = m->e11 * (m->e22 * m->e33 - m->e32 * m->e23) -
- m->e12 * (m->e21 * m->e33 - m->e23 * m->e31) +
- m->e13 * (m->e21 * m->e32 - m->e22 * m->e31);
-
- if (fabsf(det) < FLT_EPSILON) return false;
-
- auto invDet = 1 / det;
-
- invM->e11 = (m->e22 * m->e33 - m->e32 * m->e23) * invDet;
- invM->e12 = (m->e13 * m->e32 - m->e12 * m->e33) * invDet;
- invM->e13 = (m->e12 * m->e23 - m->e13 * m->e22) * invDet;
- invM->e21 = (m->e23 * m->e31 - m->e21 * m->e33) * invDet;
- invM->e22 = (m->e11 * m->e33 - m->e13 * m->e31) * invDet;
- invM->e23 = (m->e21 * m->e13 - m->e11 * m->e23) * invDet;
- invM->e31 = (m->e21 * m->e32 - m->e31 * m->e22) * invDet;
- invM->e32 = (m->e31 * m->e12 - m->e11 * m->e32) * invDet;
- invM->e33 = (m->e11 * m->e22 - m->e21 * m->e12) * invDet;
-
- return true;
-}
-
-
-bool mathMultiply(const Matrix* lhs, Matrix* rhs)
-{
- Matrix m;
-
- m.e11 = lhs->e11 * rhs->e11 + lhs->e12 * rhs->e21 + lhs->e13 * rhs->e31;
- m.e12 = lhs->e11 * rhs->e12 + lhs->e12 * rhs->e22 + lhs->e13 * rhs->e32;
- m.e13 = lhs->e11 * rhs->e13 + lhs->e12 * rhs->e23 + lhs->e13 * rhs->e33;
-
- m.e21 = lhs->e21 * rhs->e11 + lhs->e22 * rhs->e21 + lhs->e23 * rhs->e31;
- m.e22 = lhs->e21 * rhs->e12 + lhs->e22 * rhs->e22 + lhs->e23 * rhs->e32;
- m.e23 = lhs->e21 * rhs->e13 + lhs->e22 * rhs->e23 + lhs->e23 * rhs->e33;
-
- m.e31 = lhs->e31 * rhs->e11 + lhs->e32 * rhs->e21 + lhs->e33 * rhs->e31;
- m.e32 = lhs->e31 * rhs->e12 + lhs->e32 * rhs->e22 + lhs->e33 * rhs->e32;
- m.e33 = lhs->e31 * rhs->e13 + lhs->e32 * rhs->e23 + lhs->e33 * rhs->e33;
-
- *rhs = m;
-
- return true;
-}
-
-
-bool mathIdentity(const Matrix* m)
-{
- if (m) {
- if (m->e11 != 1.0f || m->e12 != 0.0f || m->e13 != 0.0f ||
- m->e21 != 0.0f || m->e22 != 1.0f || m->e23 != 0.0f ||
- m->e31 != 0.0f || m->e32 != 0.0f || m->e33 != 1.0f) {
- return false;
- }
- }
-
- return true;
-}
+}
\ No newline at end of file
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
-#include <float.h>
-#include <math.h>
-#include "tvgSwCommon.h"
+#include "tvgMath.h"
#include "tvgRender.h"
+#include "tvgSwCommon.h"
#include "tvgSwRasterC.h"
#include "tvgSwRasterAvx.h"
#include "tvgSwRasterNeon.h"
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd. All rights reserved.
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef _TVG_MATH_H_
+#define _TVG_MATH_H_
+
+ #define _USE_MATH_DEFINES
+
+#include <float.h>
+#include <math.h>
+#include "tvgCommon.h"
+
+
+static inline bool mathIdentity(const Matrix* m)
+{
+ if (m) {
+ if (fabs(m->e11 - 1) > FLT_EPSILON || fabs(m->e12) > FLT_EPSILON || fabs(m->e13) > FLT_EPSILON ||
+ fabs(m->e21) > FLT_EPSILON || fabs(m->e22 - 1) > FLT_EPSILON || fabs(m->e23) > FLT_EPSILON ||
+ fabs(m->e31) > FLT_EPSILON || fabs(m->e32) > FLT_EPSILON || fabs(m->e33 - 1) > FLT_EPSILON) {
+ return false;
+ }
+ }
+ return true;
+}
+
+
+static inline bool mathInverse(const Matrix* m, Matrix* out)
+{
+ auto det = m->e11 * (m->e22 * m->e33 - m->e32 * m->e23) -
+ m->e12 * (m->e21 * m->e33 - m->e23 * m->e31) +
+ m->e13 * (m->e21 * m->e32 - m->e22 * m->e31);
+
+ if (fabsf(det) < FLT_EPSILON) return false;
+
+ auto invDet = 1 / det;
+
+ out->e11 = (m->e22 * m->e33 - m->e32 * m->e23) * invDet;
+ out->e12 = (m->e13 * m->e32 - m->e12 * m->e33) * invDet;
+ out->e13 = (m->e12 * m->e23 - m->e13 * m->e22) * invDet;
+ out->e21 = (m->e23 * m->e31 - m->e21 * m->e33) * invDet;
+ out->e22 = (m->e11 * m->e33 - m->e13 * m->e31) * invDet;
+ out->e23 = (m->e21 * m->e13 - m->e11 * m->e23) * invDet;
+ out->e31 = (m->e21 * m->e32 - m->e31 * m->e22) * invDet;
+ out->e32 = (m->e31 * m->e12 - m->e11 * m->e32) * invDet;
+ out->e33 = (m->e11 * m->e22 - m->e21 * m->e12) * invDet;
+
+ return true;
+}
+
+
+static inline void mathIdentity(Matrix* m)
+{
+ m->e11 = 1.0f;
+ m->e12 = 0.0f;
+ m->e13 = 0.0f;
+ m->e21 = 0.0f;
+ m->e22 = 1.0f;
+ m->e23 = 0.0f;
+ m->e31 = 0.0f;
+ m->e32 = 0.0f;
+ m->e33 = 1.0f;
+}
+
+
+static inline void mathScale(Matrix* m, float scale)
+{
+ m->e11 = scale;
+ m->e22 = scale;
+}
+
+
+static inline void mathTranslate(Matrix* m, float x, float y)
+{
+ m->e13 = x;
+ m->e23 = y;
+}
+
+
+static inline void mathRotate(Matrix* m, float degree)
+{
+ auto radian = degree / 180.0f * M_PI;
+ auto cosVal = cosf(radian);
+ auto sinVal = sinf(radian);
+
+ m->e12 = m->e11 * -sinVal;
+ m->e11 *= cosVal;
+ m->e21 = m->e22 * sinVal;
+ m->e22 *= cosVal;
+}
+
+
+static inline void mathMultiply(Point* pt, const Matrix* transform)
+{
+ auto tx = pt->x * transform->e11 + pt->y * transform->e12 + transform->e13;
+ auto ty = pt->x * transform->e21 + pt->y * transform->e22 + transform->e23;
+ pt->x = tx;
+ pt->y = ty;
+}
+
+
+static inline Matrix mathMultiply(const Matrix* lhs, const Matrix* rhs)
+{
+ Matrix m;
+
+ m.e11 = lhs->e11 * rhs->e11 + lhs->e12 * rhs->e21 + lhs->e13 * rhs->e31;
+ m.e12 = lhs->e11 * rhs->e12 + lhs->e12 * rhs->e22 + lhs->e13 * rhs->e32;
+ m.e13 = lhs->e11 * rhs->e13 + lhs->e12 * rhs->e23 + lhs->e13 * rhs->e33;
+
+ m.e21 = lhs->e21 * rhs->e11 + lhs->e22 * rhs->e21 + lhs->e23 * rhs->e31;
+ m.e22 = lhs->e21 * rhs->e12 + lhs->e22 * rhs->e22 + lhs->e23 * rhs->e32;
+ m.e23 = lhs->e21 * rhs->e13 + lhs->e22 * rhs->e23 + lhs->e23 * rhs->e33;
+
+ m.e31 = lhs->e31 * rhs->e11 + lhs->e32 * rhs->e21 + lhs->e33 * rhs->e31;
+ m.e32 = lhs->e31 * rhs->e12 + lhs->e32 * rhs->e22 + lhs->e33 * rhs->e32;
+ m.e33 = lhs->e31 * rhs->e13 + lhs->e32 * rhs->e23 + lhs->e33 * rhs->e33;
+
+ return m;
+}
+
+
+#endif //_TVG_MATH_H_
\ No newline at end of file
*/
#include <float.h>
#include <math.h>
+#include "tvgMath.h"
#include "tvgPaint.h"
/************************************************************************/
auto x2 = -FLT_MAX;
auto y2 = -FLT_MAX;
- //function = Point * Matrix
- auto multiply = [&](Point* pt, const Matrix* transform) {
- auto tx = pt->x * transform->e11 + pt->y * transform->e12 + transform->e13;
- auto ty = pt->x * transform->e21 + pt->y * transform->e22 + transform->e23;
- pt->x = tx;
- pt->y = ty;
- };
-
//Compute the AABB after transformation
for (int i = 0; i < 4; i++) {
- multiply(&pt[i], m);
+ mathMultiply(&pt[i], m);
if (pt[i].x < x1) x1 = pt[i].x;
if (pt[i].x > x2) x2 = pt[i].x;
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
-#include <float.h>
-#include <math.h>
+#include "tvgMath.h"
#include "tvgRender.h"
/************************************************************************/
bool RenderTransform::update()
{
- constexpr auto PI = 3.141592f;
-
if (overriding) return true;
//Init Status
return false;
}
- //identity
- m.e11 = 1.0f;
- m.e12 = 0.0f;
- m.e13 = 0.0f;
- m.e21 = 0.0f;
- m.e22 = 1.0f;
- m.e23 = 0.0f;
- m.e31 = 0.0f;
- m.e32 = 0.0f;
- m.e33 = 1.0f;
-
- //scale
- m.e11 = scale;
- m.e22 = scale;
-
- //rotation
- if (fabsf(degree) > FLT_EPSILON) {
- auto radian = degree / 180.0f * PI;
- auto cosVal = cosf(radian);
- auto sinVal = sinf(radian);
-
- m.e12 = m.e11 * -sinVal;
- m.e11 *= cosVal;
- m.e21 = m.e22 * sinVal;
- m.e22 *= cosVal;
- }
+ mathIdentity(&m);
+
+ mathScale(&m, scale);
+
+ if (fabsf(degree) > FLT_EPSILON) mathRotate(&m, degree);
- m.e13 = x;
- m.e23 = y;
+ mathTranslate(&m, x, y);
return true;
}
RenderTransform::RenderTransform(const RenderTransform* lhs, const RenderTransform* rhs)
{
- m.e11 = lhs->m.e11 * rhs->m.e11 + lhs->m.e12 * rhs->m.e21 + lhs->m.e13 * rhs->m.e31;
- m.e12 = lhs->m.e11 * rhs->m.e12 + lhs->m.e12 * rhs->m.e22 + lhs->m.e13 * rhs->m.e32;
- m.e13 = lhs->m.e11 * rhs->m.e13 + lhs->m.e12 * rhs->m.e23 + lhs->m.e13 * rhs->m.e33;
-
- m.e21 = lhs->m.e21 * rhs->m.e11 + lhs->m.e22 * rhs->m.e21 + lhs->m.e23 * rhs->m.e31;
- m.e22 = lhs->m.e21 * rhs->m.e12 + lhs->m.e22 * rhs->m.e22 + lhs->m.e23 * rhs->m.e32;
- m.e23 = lhs->m.e21 * rhs->m.e13 + lhs->m.e22 * rhs->m.e23 + lhs->m.e23 * rhs->m.e33;
-
- m.e31 = lhs->m.e31 * rhs->m.e11 + lhs->m.e32 * rhs->m.e21 + lhs->m.e33 * rhs->m.e31;
- m.e32 = lhs->m.e31 * rhs->m.e12 + lhs->m.e32 * rhs->m.e22 + lhs->m.e33 * rhs->m.e32;
- m.e33 = lhs->m.e31 * rhs->m.e13 + lhs->m.e32 * rhs->m.e23 + lhs->m.e33 * rhs->m.e33;
-}
+ m = mathMultiply(&lhs->m, &rhs->m);
+}
\ No newline at end of file
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
-#include <float.h>
-#include <math.h>
+#include "tvgMath.h"
#include "tvgSaveModule.h"
#include "tvgTvgSaver.h"
#include "tvgLzw.h"
}
-static Matrix _multiply(const Matrix* lhs, const Matrix* rhs)
-{
- Matrix m;
-
- m.e11 = lhs->e11 * rhs->e11 + lhs->e12 * rhs->e21 + lhs->e13 * rhs->e31;
- m.e12 = lhs->e11 * rhs->e12 + lhs->e12 * rhs->e22 + lhs->e13 * rhs->e32;
- m.e13 = lhs->e11 * rhs->e13 + lhs->e12 * rhs->e23 + lhs->e13 * rhs->e33;
-
- m.e21 = lhs->e21 * rhs->e11 + lhs->e22 * rhs->e21 + lhs->e23 * rhs->e31;
- m.e22 = lhs->e21 * rhs->e12 + lhs->e22 * rhs->e22 + lhs->e23 * rhs->e32;
- m.e23 = lhs->e21 * rhs->e13 + lhs->e22 * rhs->e23 + lhs->e23 * rhs->e33;
-
- m.e31 = lhs->e31 * rhs->e11 + lhs->e32 * rhs->e21 + lhs->e33 * rhs->e31;
- m.e32 = lhs->e31 * rhs->e12 + lhs->e32 * rhs->e22 + lhs->e33 * rhs->e32;
- m.e33 = lhs->e31 * rhs->e13 + lhs->e32 * rhs->e23 + lhs->e33 * rhs->e33;
-
- return m;
-}
-
-
-static void _multiply(Point* pt, const Matrix* transform)
-{
- auto tx = pt->x * transform->e11 + pt->y * transform->e12 + transform->e13;
- auto ty = pt->x * transform->e21 + pt->y * transform->e22 + transform->e23;
- pt->x = tx;
- pt->y = ty;
-}
-
-
/* if the properties are identical, we can merge the shapes. */
static bool _merge(Shape* from, Shape* to)
{
TvgBinCounter TvgSaver::writeTransform(const Matrix* transform, TvgBinTag tag)
{
- if (fabs(transform->e11 - 1) > FLT_EPSILON || fabs(transform->e12) > FLT_EPSILON || fabs(transform->e13) > FLT_EPSILON ||
- fabs(transform->e21) > FLT_EPSILON || fabs(transform->e22 - 1) > FLT_EPSILON || fabs(transform->e23) > FLT_EPSILON ||
- fabs(transform->e31) > FLT_EPSILON || fabs(transform->e32) > FLT_EPSILON || fabs(transform->e33 - 1) > FLT_EPSILON) {
- return writeTagProperty(tag, SIZE(Matrix), transform);
- }
+ if (!mathIdentity(transform)) return writeTagProperty(tag, SIZE(Matrix), transform);
return 0;
}
cnt += writeTagProperty(TVG_TAG_FILL_COLORSTOPS, stopsCnt * SIZE(Fill::ColorStop), stops);
auto gTransform = fill->transform();
- if (pTransform) gTransform = _multiply(pTransform, &gTransform);
+ if (pTransform) gTransform = mathMultiply(pTransform, &gTransform);
+
cnt += writeTransform(&gTransform, TVG_TAG_FILL_TRANSFORM);
writeReservedCount(cnt);
fabs(transform->e21) > FLT_EPSILON || fabs(transform->e22 - 1) > FLT_EPSILON || fabs(transform->e23) > FLT_EPSILON ||
fabs(transform->e31) > FLT_EPSILON || fabs(transform->e32) > FLT_EPSILON || fabs(transform->e33 - 1) > FLT_EPSILON) {
auto p = const_cast<Point*>(pts);
- for (uint32_t i = 0; i < ptsCnt; ++i) _multiply(p++, transform);
+ for (uint32_t i = 0; i < ptsCnt; ++i) mathMultiply(p++, transform);
}
}
if (!compTarget && paint->opacity() == 0) return 0;
auto transform = const_cast<Paint*>(paint)->transform();
- if (pTransform) transform = _multiply(pTransform, &transform);
+ if (pTransform) transform = mathMultiply(pTransform, &transform);
switch (paint->identifier()) {
case TVG_CLASS_ID_SHAPE: return serializeShape(static_cast<const Shape*>(paint), pTransform, &transform);