this interface is designed for user-defined arbitrary affine-transform paints.
required by svg loader.
Change-Id: I7f08023605d224e36cef3770098d3757aee81848
testDirectUpdate
testScene
testTransform
+testCustomTransform
testSceneTransform
testStroke
testStrokeLine
};
+struct Matrix
+{
+ float e11, e12, e13;
+ float e21, e22, e23;
+ float e31, e32, e33;
+};
+
+
/**
* @class Paint
*
public:
virtual ~Paint() {}
- virtual Result rotate(float degree) = 0;
- virtual Result scale(float factor) = 0;
- virtual Result translate(float x, float y) = 0;
-
- virtual Result bounds(float* x, float* y, float* w, float* h) const = 0;
-
_TVG_DECALRE_IDENTIFIER();
};
Result fill(std::unique_ptr<Fill> f) noexcept;
//Transform
- Result rotate(float degree) noexcept override;
- Result scale(float factor) noexcept override;
- Result translate(float x, float y) noexcept override;
+ Result rotate(float degree) noexcept;
+ Result scale(float factor) noexcept;
+ Result translate(float x, float y) noexcept;
+ Result transform(const Matrix& m) noexcept;
//Getters
uint32_t pathCommands(const PathCommand** cmds) const noexcept;
uint32_t pathCoords(const Point** pts) const noexcept;
Result fill(uint8_t* r, uint8_t* g, uint8_t* b, uint8_t* a) const noexcept;
const Fill* fill() const noexcept;
- Result bounds(float* x, float* y, float* w, float* h) const noexcept override;
+ Result bounds(float* x, float* y, float* w, float* h) const noexcept;
float strokeWidth() const noexcept;
Result strokeColor(uint8_t* r, uint8_t* g, uint8_t* b, uint8_t* a) const noexcept;
Result push(std::unique_ptr<Paint> paint) noexcept;
Result reserve(uint32_t size) noexcept;
-
Result load(const std::string& path) noexcept;
- Result rotate(float degree) noexcept override;
- Result scale(float factor) noexcept override;
- Result translate(float x, float y) noexcept override;
+ Result rotate(float degree) noexcept;
+ Result scale(float factor) noexcept;
+ Result translate(float x, float y) noexcept;
+ Result transform(const Matrix& m) noexcept;
- Result bounds(float* x, float* y, float* w, float* h) const noexcept override;
+ Result bounds(float* x, float* y, float* w, float* h) const noexcept;
static std::unique_ptr<Scene> gen() noexcept;
auto cy = (y2 - y1) * 0.5f + y1;
auto dx = x1 - cx;
auto dy = y1 - cy;
- x1 = dx * transform->e11 + dy * transform->e12 + transform->e31;
- y1 = dx * transform->e21 + dy * transform->e22 + transform->e32;
+ x1 = dx * transform->m.e11 + dy * transform->m.e12 + transform->m.e31;
+ y1 = dx * transform->m.e21 + dy * transform->m.e22 + transform->m.e32;
dx = x2 - cx;
dy = y2 - cy;
- x2 = dx * transform->e11 + dy * transform->e12 + transform->e31;
- y2 = dx * transform->e21 + dy * transform->e22 + transform->e32;
+ x2 = dx * transform->m.e11 + dy * transform->m.e12 + transform->m.e31;
+ y2 = dx * transform->m.e21 + dy * transform->m.e22 + transform->m.e32;
}
fill->linear.dx = x2 - x1;
if (radius < FLT_EPSILON) return true;
if (transform) {
- auto tx = fill->radial.cx * transform->e11 + fill->radial.cy * transform->e12 + transform->e31;
- auto ty = fill->radial.cx * transform->e21 + fill->radial.cy * transform->e22 + transform->e32;
+ auto tx = fill->radial.cx * transform->m.e11 + fill->radial.cy * transform->m.e12 + transform->m.e31;
+ auto ty = fill->radial.cx * transform->m.e21 + fill->radial.cy * transform->m.e22 + transform->m.e32;
fill->radial.cx = tx;
fill->radial.cy = ty;
- radius *= transform->e33;
+ radius *= transform->m.e33;
}
fill->radial.a = radius * radius;
for(uint32_t i = 0; i < outline->ptsCnt; ++i) {
auto dx = static_cast<float>(outline->pts[i].x >> 6);
auto dy = static_cast<float>(outline->pts[i].y >> 6);
- auto tx = dx * transform->e11 + dy * transform->e12 + transform->e31;
- auto ty = dx * transform->e21 + dy * transform->e22 + transform->e32;
+ auto tx = dx * transform->m.e11 + dy * transform->m.e12 + transform->m.e31;
+ auto ty = dx * transform->m.e21 + dy * transform->m.e22 + transform->m.e32;
auto pt = Point{tx, ty};
outline->pts[i] = TO_SWPOINT(&pt);
}
/* External Class Implementation */
/************************************************************************/
+void RenderTransform::override(const Matrix& m)
+{
+ this->m = m;
+
+ if (m.e11 == 0.0f && m.e12 == 0.0f && m.e13 == 0.0f &&
+ m.e21 == 0.0f && m.e22 == 0.0f && m.e23 == 0.0f &&
+ m.e31 == 0.0f && m.e32 == 0.0f && m.e33 == 0.0f) {
+ overriding = false;
+ } else overriding = true;
+}
+
+
bool RenderTransform::update()
{
constexpr auto PI = 3.141592f;
+ if (overriding) return true;
+
//Init Status
if (fabsf(x) <= FLT_EPSILON && fabsf(y) <= FLT_EPSILON &&
fabsf(degree) <= FLT_EPSILON && fabsf(factor - 1) <= FLT_EPSILON) {
}
//identity
- e11 = 1.0f;
- e12 = 0.0f;
- e13 = 0.0f;
- e21 = 0.0f;
- e22 = 1.0f;
- e23 = 0.0f;
- e31 = 0.0f;
- e32 = 0.0f;
- e33 = 1.0f;
+ 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
- e11 *= factor;
- e22 *= factor;
- e33 *= factor;
+ m.e11 *= factor;
+ m.e22 *= factor;
+ m.e33 *= factor;
//rotation
if (fabsf(degree) > FLT_EPSILON) {
auto cosVal = cosf(radian);
auto sinVal = sinf(radian);
- auto t11 = e11 * cosVal + e12 * sinVal;
- auto t12 = e11 * -sinVal + e12 * cosVal;
- auto t21 = e21 * cosVal + e22 * sinVal;
- auto t22 = e21 * -sinVal + e22 * cosVal;
- auto t31 = e31 * cosVal + e32 * sinVal;
- auto t32 = e31 * -sinVal + e32 * cosVal;
-
- e11 = t11;
- e12 = t12;
- e21 = t21;
- e22 = t22;
- e31 = t31;
- e32 = t32;
+ auto t11 = m.e11 * cosVal + m.e12 * sinVal;
+ auto t12 = m.e11 * -sinVal + m.e12 * cosVal;
+ auto t21 = m.e21 * cosVal + m.e22 * sinVal;
+ auto t22 = m.e21 * -sinVal + m.e22 * cosVal;
+ auto t31 = m.e31 * cosVal + m.e32 * sinVal;
+ auto t32 = m.e31 * -sinVal + m.e32 * cosVal;
+
+ m.e11 = t11;
+ m.e12 = t12;
+ m.e21 = t21;
+ m.e22 = t22;
+ m.e31 = t31;
+ m.e32 = t32;
}
- e31 += x;
- e32 += y;
+ m.e31 += x;
+ m.e32 += y;
return true;
}
auto dx = rhs->x * lhs->factor;
auto dy = rhs->y * lhs->factor;
- auto tx = dx * lhs->e11 + dy * lhs->e12 + lhs->e13;
- auto ty = dx * lhs->e21 + dy * lhs->e22 + lhs->e23;
+ auto tx = dx * lhs->m.e11 + dy * lhs->m.e12 + lhs->m.e13;
+ auto ty = dx * lhs->m.e21 + dy * lhs->m.e22 + lhs->m.e23;
x = lhs->x + tx;
y = lhs->y + ty;
struct RenderTransform
{
- //3x3 Matrix Elements
- float e11, e12, e13;
- float e21, e22, e23;
- float e31, e32, e33;
-
+ Matrix m; //3x3 Matrix Elements
float x = 0.0f;
float y = 0.0f;
float degree = 0.0f; //rotation degree
float factor = 1.0f; //scale factor
+ bool overriding = false; //user transform?
bool update();
+ void override(const Matrix& m);
RenderTransform();
RenderTransform(const RenderTransform* lhs, const RenderTransform* rhs);
}
+Result Scene::transform(const Matrix& m) noexcept
+{
+ auto impl = pImpl.get();
+ if (!impl) return Result::MemoryCorruption;
+
+ if (!impl->transform(m)) return Result::FailedAllocation;
+
+ return Result::Success;
+}
+
+
Result Scene::bounds(float* x, float* y, float* w, float* h) const noexcept
{
auto impl = pImpl.get();
struct Scene::Impl
{
vector<Paint*> paints;
- RenderTransform *transform = nullptr;
+ RenderTransform *rTransform = nullptr;
uint32_t flag = RenderUpdateFlag::None;
unique_ptr<Loader> loader = nullptr;
{
//Are you sure clear() prior to this?
assert(paints.empty());
- if (transform) delete(transform);
+ if (rTransform) delete(rTransform);
}
bool clear(RenderMethod& renderer)
}
if (flag & RenderUpdateFlag::Transform) {
- if (!transform) return false;
- if (!transform->update()) {
- delete(transform);
- transform = nullptr;
+ if (!rTransform) return false;
+ if (!rTransform->update()) {
+ delete(rTransform);
+ rTransform = nullptr;
}
}
auto ret = true;
- if (transform && pTransform) {
- RenderTransform outTransform(pTransform, transform);
+ if (rTransform && pTransform) {
+ RenderTransform outTransform(pTransform, rTransform);
ret = updateInternal(renderer, &outTransform, pFlag | flag);
} else {
- auto outTransform = pTransform ? pTransform : transform;
+ auto outTransform = pTransform ? pTransform : rTransform;
ret = updateInternal(renderer, outTransform, pFlag | flag);
}
bool scale(float factor)
{
- if (transform) {
- if (fabsf(factor - transform->factor) <= FLT_EPSILON) return true;
+ if (rTransform) {
+ if (fabsf(factor - rTransform->factor) <= FLT_EPSILON) return true;
} else {
if (fabsf(factor) <= FLT_EPSILON) return true;
- transform = new RenderTransform();
- if (!transform) return false;
+ rTransform = new RenderTransform();
+ if (!rTransform) return false;
}
- transform->factor = factor;
+ rTransform->factor = factor;
flag |= RenderUpdateFlag::Transform;
return true;
bool rotate(float degree)
{
- if (transform) {
- if (fabsf(degree - transform->degree) <= FLT_EPSILON) return true;
+ if (rTransform) {
+ if (fabsf(degree - rTransform->degree) <= FLT_EPSILON) return true;
} else {
if (fabsf(degree) <= FLT_EPSILON) return true;
- transform = new RenderTransform();
- if (!transform) return false;
+ rTransform = new RenderTransform();
+ if (!rTransform) return false;
}
- transform->degree = degree;
+ rTransform->degree = degree;
flag |= RenderUpdateFlag::Transform;
return true;
bool translate(float x, float y)
{
- if (transform) {
- if (fabsf(x - transform->x) <= FLT_EPSILON && fabsf(y - transform->y) <= FLT_EPSILON) return true;
+ if (rTransform) {
+ if (fabsf(x - rTransform->x) <= FLT_EPSILON && fabsf(y - rTransform->y) <= FLT_EPSILON) return true;
} else {
if (fabsf(x) <= FLT_EPSILON && fabsf(y) <= FLT_EPSILON) return true;
- transform = new RenderTransform();
- if (!transform) return false;
+ rTransform = new RenderTransform();
+ if (!rTransform) return false;
}
- transform->x = x;
- transform->y = y;
+ rTransform->x = x;
+ rTransform->y = y;
flag |= RenderUpdateFlag::Transform;
return true;
}
+
+ bool transform(const Matrix& m)
+ {
+ if (!rTransform) {
+ rTransform = new RenderTransform();
+ if (!rTransform) return false;
+ }
+ rTransform->override(m);
+ flag |= RenderUpdateFlag::Transform;
+
+ return true;
+ }
+
+
Result load(const string& path)
{
if (loader) loader->close();
auto impl = pImpl.get();
if (!impl) return Result::MemoryCorruption;
- impl->translate(x, y);
+ if (!impl->translate(x, y)) return Result::FailedAllocation;
+
+ return Result::Success;
+}
+
+
+Result Shape::transform(const Matrix& m) noexcept
+{
+ auto impl = pImpl.get();
+ if (!impl) return Result::MemoryCorruption;
+
+ if (!impl->transform(m)) return Result::FailedAllocation;
return Result::Success;
}
ShapePath *path = nullptr;
Fill *fill = nullptr;
ShapeStroke *stroke = nullptr;
- RenderTransform *transform = nullptr;
+ RenderTransform *rTransform = nullptr;
uint8_t color[4] = {0, 0, 0, 0}; //r, g, b, a
uint32_t flag = RenderUpdateFlag::None;
void *edata = nullptr; //engine data
if (path) delete(path);
if (fill) delete(fill);
if (stroke) delete(stroke);
- if (transform) delete(transform);
+ if (rTransform) delete(rTransform);
}
bool dispose(Shape& shape, RenderMethod& renderer)
bool update(Shape& shape, RenderMethod& renderer, const RenderTransform* pTransform = nullptr, uint32_t pFlag = 0)
{
if (flag & RenderUpdateFlag::Transform) {
- if (!transform) return false;
- if (!transform->update()) {
- delete(transform);
- transform = nullptr;
+ if (!rTransform) return false;
+ if (!rTransform->update()) {
+ delete(rTransform);
+ rTransform = nullptr;
}
}
- if (transform && pTransform) {
- RenderTransform outTransform(pTransform, transform);
+ if (rTransform && pTransform) {
+ RenderTransform outTransform(pTransform, rTransform);
edata = renderer.prepare(shape, edata, &outTransform, static_cast<RenderUpdateFlag>(pFlag | flag));
} else {
- auto outTransform = pTransform ? pTransform : transform;
+ auto outTransform = pTransform ? pTransform : rTransform;
edata = renderer.prepare(shape, edata, outTransform, static_cast<RenderUpdateFlag>(pFlag | flag));
}
bool scale(float factor)
{
- if (transform) {
- if (fabsf(factor - transform->factor) <= FLT_EPSILON) return true;
+ if (rTransform) {
+ if (fabsf(factor - rTransform->factor) <= FLT_EPSILON) return true;
} else {
if (fabsf(factor) <= FLT_EPSILON) return true;
- transform = new RenderTransform();
- if (!transform) return false;
+ rTransform = new RenderTransform();
+ if (!rTransform) return false;
}
- transform->factor = factor;
- flag |= RenderUpdateFlag::Transform;
+ rTransform->factor = factor;
+ if (!rTransform->overriding) flag |= RenderUpdateFlag::Transform;
return true;
}
bool rotate(float degree)
{
- if (transform) {
- if (fabsf(degree - transform->degree) <= FLT_EPSILON) return true;
+ if (rTransform) {
+ if (fabsf(degree - rTransform->degree) <= FLT_EPSILON) return true;
} else {
if (fabsf(degree) <= FLT_EPSILON) return true;
- transform = new RenderTransform();
- if (!transform) return false;
+ rTransform = new RenderTransform();
+ if (!rTransform) return false;
}
- transform->degree = degree;
- flag |= RenderUpdateFlag::Transform;
+ rTransform->degree = degree;
+ if (!rTransform->overriding) flag |= RenderUpdateFlag::Transform;
return true;
}
bool translate(float x, float y)
{
- if (transform) {
- if (fabsf(x - transform->x) <= FLT_EPSILON && fabsf(y - transform->y) <= FLT_EPSILON) return true;
+ if (rTransform) {
+ if (fabsf(x - rTransform->x) <= FLT_EPSILON && fabsf(y - rTransform->y) <= FLT_EPSILON) return true;
} else {
if (fabsf(x) <= FLT_EPSILON && fabsf(y) <= FLT_EPSILON) return true;
- transform = new RenderTransform();
- if (!transform) return false;
+ rTransform = new RenderTransform();
+ if (!rTransform) return false;
+ }
+ rTransform->x = x;
+ rTransform->y = y;
+ if (!rTransform->overriding) flag |= RenderUpdateFlag::Transform;
+
+ return true;
+ }
+
+
+ bool transform(const Matrix& m)
+ {
+ if (!rTransform) {
+ rTransform = new RenderTransform();
+ if (!rTransform) return false;
}
- transform->x = x;
- transform->y = y;
+ rTransform->override(m);
flag |= RenderUpdateFlag::Transform;
return true;
}
+
bool strokeWidth(float width)
{
//TODO: Size Exception?
gcc -o testDirectUpdate testDirectUpdate.cpp -g -lstdc++ `pkg-config --cflags --libs elementary tizenvg`
gcc -o testScene testScene.cpp -g -lstdc++ `pkg-config --cflags --libs elementary tizenvg`
gcc -o testTransform testTransform.cpp -g -lstdc++ `pkg-config --cflags --libs elementary tizenvg`
+ gcc -o testCustomTransform testCustomTransform.cpp -g -lstdc++ `pkg-config --cflags --libs elementary tizenvg`
gcc -o testSceneTransform testSceneTransform.cpp -g -lstdc++ `pkg-config --cflags --libs elementary tizenvg`
gcc -o testStroke testStroke.cpp -g -lstdc++ `pkg-config --cflags --libs elementary tizenvg`
gcc -o testStrokeLine testStrokeLine.cpp -g -lstdc++ `pkg-config --cflags --libs elementary tizenvg`
--- /dev/null
+#include <tizenvg.h>
+#include <Elementary.h>
+
+using namespace std;
+
+#define WIDTH 800
+#define HEIGHT 800
+
+static uint32_t buffer[WIDTH * HEIGHT];
+unique_ptr<tvg::SwCanvas> canvas = nullptr;
+tvg::Shape* pShape = nullptr;
+
+void tvgtest()
+{
+ //Create a Canvas
+ canvas = tvg::SwCanvas::gen();
+ canvas->target(buffer, WIDTH, WIDTH, HEIGHT);
+
+ //Shape1
+ auto shape = tvg::Shape::gen();
+
+ /* Acquire shape pointer to access it again.
+ instead, you should consider not to interrupt this pointer life-cycle. */
+ pShape = shape.get();
+
+ shape->moveTo(0, -114.5);
+ shape->lineTo(54, -5.5);
+ shape->lineTo(175, 11.5);
+ shape->lineTo(88, 95.5);
+ shape->lineTo(108, 216.5);
+ shape->lineTo(0, 160.5);
+ shape->lineTo(-102, 216.5);
+ shape->lineTo(-87, 96.5);
+ shape->lineTo(-173, 12.5);
+ shape->lineTo(-53, -5.5);
+ shape->close();
+ shape->fill(0, 0, 255, 255);
+ canvas->push(move(shape));
+
+ //Draw first frame
+ canvas->draw();
+ canvas->sync();
+}
+
+void transit_cb(Elm_Transit_Effect *effect, Elm_Transit* transit, double progress)
+{
+ /* Update shape directly.
+ You can update only necessary properties of this shape,
+ while retaining other properties. */
+
+ //Transform Matrix
+ tvg::Matrix m = {1, 0, 0, 0, 1, 0, 0, 0, 1};
+
+ //scale x
+ m.e11 = 1 - (progress * 0.5f);
+
+ //scale y
+ m.e22 = 1 + (progress * 2.0f);
+
+ //rotation
+ constexpr auto PI = 3.141592f;
+ auto degree = 45.0f;
+ auto radian = degree / 180.0f * PI;
+ auto cosVal = cosf(radian);
+ auto sinVal = sinf(radian);
+
+ auto t11 = m.e11 * cosVal + m.e12 * sinVal;
+ auto t12 = m.e11 * -sinVal + m.e12 * cosVal;
+ auto t21 = m.e21 * cosVal + m.e22 * sinVal;
+ auto t22 = m.e21 * -sinVal + m.e22 * cosVal;
+ auto t31 = m.e31 * cosVal + m.e32 * sinVal;
+ auto t32 = m.e31 * -sinVal + m.e32 * cosVal;
+
+ m.e11 = t11;
+ m.e12 = t12;
+ m.e21 = t21;
+ m.e22 = t22;
+ m.e31 = t31;
+ m.e32 = t32;
+
+ //translate
+ m.e31 = progress * 300.0f + 300.0f;
+ m.e32 = progress * -100.0f + 300.0f;
+
+ pShape->transform(m);
+
+ //Update shape for drawing (this may work asynchronously)
+ canvas->update(pShape);
+
+ //Draw Next frames
+ canvas->draw();
+ canvas->sync();
+
+ //Update Efl Canvas
+ Eo* img = (Eo*) effect;
+ evas_object_image_data_update_add(img, 0, 0, WIDTH, HEIGHT);
+}
+
+void
+win_del(void *data, Evas_Object *o, void *ev)
+{
+ elm_exit();
+}
+
+int main(int argc, char **argv)
+{
+ //Initialize TizenVG Engine
+ tvg::Initializer::init(tvg::CanvasEngine::Sw);
+
+ tvgtest();
+
+ //Show the result using EFL...
+ elm_init(argc, argv);
+
+ Eo* win = elm_win_util_standard_add(NULL, "TizenVG Test");
+ evas_object_smart_callback_add(win, "delete,request", win_del, 0);
+
+ Eo* img = evas_object_image_filled_add(evas_object_evas_get(win));
+ evas_object_image_size_set(img, WIDTH, HEIGHT);
+ evas_object_image_data_set(img, buffer);
+ evas_object_size_hint_weight_set(img, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ evas_object_show(img);
+
+ elm_win_resize_object_add(win, img);
+ evas_object_geometry_set(win, 0, 0, WIDTH, HEIGHT);
+ evas_object_show(win);
+
+ Elm_Transit *transit = elm_transit_add();
+ elm_transit_effect_add(transit, transit_cb, img, nullptr);
+ elm_transit_duration_set(transit, 2);
+ elm_transit_repeat_times_set(transit, -1);
+ elm_transit_auto_reverse_set(transit, EINA_TRUE);
+ elm_transit_go(transit);
+
+ elm_run();
+ elm_shutdown();
+
+ //Terminate TizenVG Engine
+ tvg::Initializer::term(tvg::CanvasEngine::Sw);
+}
projects / platform / core / graphics / tizenvg.git / commitdiff