#ifndef _TVG_PAINT_H_
#define _TVG_PAINT_H_
-#include <float.h>
-#include <math.h>
#include "tvgRender.h"
-static inline bool FLT_SAME(float a, float b)
-{
- return (fabsf(a - b) < FLT_EPSILON);
-}
-
-static bool _clipPathFastTrack(Paint* cmpTarget, const RenderTransform* transform, RenderRegion& viewport)
-{
- /* Access Shape class by Paint is bad... but it's ok still it's an internal usage. */
- auto shape = static_cast<Shape*>(cmpTarget);
-
- //Rectangle Candidates?
- const Point* pts;
- if (shape->pathCoords(&pts) != 4) return false;
-
- //No Rotation?
- if (transform) {
- if (transform->m.e12 != 0 || transform->m.e21 != 0 || transform->m.e11 != transform->m.e22) return false;
- }
-
- //Othogonal Rectangle?
- auto pt1 = pts + 0;
- auto pt2 = pts + 1;
- auto pt3 = pts + 2;
- auto pt4 = pts + 3;
-
- if ((FLT_SAME(pt1->x, pt2->x) && FLT_SAME(pt2->y, pt3->y) && FLT_SAME(pt3->x, pt4->x) && FLT_SAME(pt1->y, pt4->y)) ||
- (FLT_SAME(pt2->x, pt3->x) && FLT_SAME(pt1->y, pt2->y) && FLT_SAME(pt1->x, pt4->x) && FLT_SAME(pt3->y, pt4->y))) {
-
- auto x1 = pt1->x;
- auto y1 = pt1->y;
- auto x2 = pt3->x;
- auto y2 = pt3->y;
-
- if (transform) {
- x1 = x1 * transform->m.e11 + transform->m.e13;
- y1 = y1 * transform->m.e22 + transform->m.e23;
- x2 = x2 * transform->m.e11 + transform->m.e13;
- y2 = y2 * transform->m.e22 + transform->m.e23;
- }
-
- viewport.x = static_cast<uint32_t>(x1);
- viewport.y = static_cast<uint32_t>(y1);
- viewport.w = static_cast<uint32_t>(roundf(x2 - x1 + 0.5f));
- viewport.h = static_cast<uint32_t>(roundf(y2 - y1 + 0.5f));
-
- return true;
- }
-
- return false;
-}
-
namespace tvg
{
- enum class PaintType { Shape = 0, Scene, Picture };
+ enum ContextFlag {Invalid = 0, FastTrack = 1};
+
+ struct Iterator
+ {
+ virtual ~Iterator() {}
+ virtual const Paint* next() = 0;
+ virtual uint32_t count() = 0;
+ virtual void begin() = 0;
+ };
struct StrategyMethod
{
virtual bool dispose(RenderMethod& renderer) = 0;
virtual void* update(RenderMethod& renderer, const RenderTransform* transform, uint32_t opacity, Array<RenderData>& clips, RenderUpdateFlag pFlag) = 0; //Return engine data if it has.
virtual bool render(RenderMethod& renderer) = 0;
- virtual bool bounds(float* x, float* y, float* w, float* h) const = 0;
+ virtual bool bounds(float* x, float* y, float* w, float* h) = 0;
virtual RenderRegion bounds(RenderMethod& renderer) const = 0;
virtual Paint* duplicate() = 0;
+ virtual Iterator* iterator() = 0;
};
struct Paint::Impl
{
StrategyMethod* smethod = nullptr;
- RenderTransform *rTransform = nullptr;
- uint32_t flag = RenderUpdateFlag::None;
-
+ RenderTransform* rTransform = nullptr;
+ uint32_t renderFlag = RenderUpdateFlag::None;
Paint* cmpTarget = nullptr;
CompositeMethod cmpMethod = CompositeMethod::None;
-
+ uint32_t ctxFlag = ContextFlag::Invalid;
+ uint32_t id;
uint8_t opacity = 255;
- PaintType type;
-
~Impl() {
if (cmpTarget) delete(cmpTarget);
if (smethod) delete(smethod);
smethod = method;
}
- bool rotate(float degree)
- {
- if (rTransform) {
- if (fabsf(degree - rTransform->degree) <= FLT_EPSILON) return true;
- } else {
- if (fabsf(degree) <= FLT_EPSILON) return true;
- rTransform = new RenderTransform();
- if (!rTransform) return false;
- }
- rTransform->degree = degree;
- if (!rTransform->overriding) flag |= RenderUpdateFlag::Transform;
-
- return true;
- }
-
- bool scale(float factor)
- {
- if (rTransform) {
- if (fabsf(factor - rTransform->scale) <= FLT_EPSILON) return true;
- } else {
- if (fabsf(factor) <= FLT_EPSILON) return true;
- rTransform = new RenderTransform();
- if (!rTransform) return false;
- }
- rTransform->scale = factor;
- if (!rTransform->overriding) flag |= RenderUpdateFlag::Transform;
-
- return true;
- }
-
- bool translate(float x, float y)
- {
- 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;
- 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) {
if (!rTransform) return false;
}
rTransform->override(m);
- flag |= RenderUpdateFlag::Transform;
+ renderFlag |= RenderUpdateFlag::Transform;
return true;
}
- bool bounds(float* x, float* y, float* w, float* h) const
+ Matrix* transform()
{
- return smethod->bounds(x, y, w, h);
+ if (rTransform) {
+ rTransform->update();
+ return &rTransform->m;
+ }
+ return nullptr;
}
RenderRegion bounds(RenderMethod& renderer) const
return smethod->dispose(renderer);
}
- void* update(RenderMethod& renderer, const RenderTransform* pTransform, uint32_t opacity, Array<RenderData>& clips, uint32_t pFlag)
- {
- if (flag & RenderUpdateFlag::Transform) {
- if (!rTransform) return nullptr;
- if (!rTransform->update()) {
- delete(rTransform);
- rTransform = nullptr;
- }
- }
-
- /* 1. Composition Pre Processing */
- void *cmpData = nullptr;
- RenderRegion viewport;
- bool cmpFastTrack = false;
-
- if (cmpTarget) {
- /* If transform has no rotation factors && ClipPath is a simple rectangle,
- we can avoid regular ClipPath sequence but use viewport for performance */
- if (cmpMethod == CompositeMethod::ClipPath) {
- RenderRegion viewport2;
- if ((cmpFastTrack = _clipPathFastTrack(cmpTarget, pTransform, viewport2))) {
- viewport = renderer.viewport();
- renderer.viewport(viewport2);
- }
- }
-
- if (!cmpFastTrack) {
- cmpData = cmpTarget->pImpl->update(renderer, pTransform, 255, clips, pFlag);
- if (cmpMethod == CompositeMethod::ClipPath) clips.push(cmpData);
- }
- }
-
- /* 2. Main Update */
- void *edata = nullptr;
- auto newFlag = static_cast<RenderUpdateFlag>(pFlag | flag);
- flag = RenderUpdateFlag::None;
- opacity = (opacity * this->opacity) / 255;
-
- if (rTransform && pTransform) {
- RenderTransform outTransform(pTransform, rTransform);
- edata = smethod->update(renderer, &outTransform, opacity, clips, newFlag);
- } else {
- auto outTransform = pTransform ? pTransform : rTransform;
- edata = smethod->update(renderer, outTransform, opacity, clips, newFlag);
- }
-
- /* 3. Composition Post Processing */
- if (cmpFastTrack) renderer.viewport(viewport);
- else if (cmpData && cmpMethod == CompositeMethod::ClipPath) clips.pop();
-
- return edata;
- }
-
- bool render(RenderMethod& renderer)
+ Iterator* iterator()
{
- Compositor* cmp = nullptr;
-
- /* Note: only ClipPath is processed in update() step.
- Create a composition image. */
- if (cmpTarget && cmpMethod != CompositeMethod::ClipPath) {
- auto region = cmpTarget->pImpl->bounds(renderer);
- if (region.w == 0 || region.h == 0) return false;
- cmp = renderer.target(region);
- renderer.beginComposite(cmp, CompositeMethod::None, 255);
- cmpTarget->pImpl->render(renderer);
- }
-
- if (cmp) renderer.beginComposite(cmp, cmpMethod, cmpTarget->pImpl->opacity);
-
- auto ret = smethod->render(renderer);
-
- if (cmp) renderer.endComposite(cmp);
-
- return ret;
- }
-
- Paint* duplicate()
- {
- auto ret = smethod->duplicate();
- if (!ret) return nullptr;
-
- //duplicate Transform
- if (rTransform) {
- ret->pImpl->rTransform = new RenderTransform();
- if (ret->pImpl->rTransform) {
- *ret->pImpl->rTransform = *rTransform;
- ret->pImpl->flag |= RenderUpdateFlag::Transform;
- }
- }
-
- ret->pImpl->opacity = opacity;
-
- if (cmpTarget) ret->pImpl->cmpTarget = cmpTarget->duplicate();
-
- ret->pImpl->cmpMethod = cmpMethod;
-
- return ret;
+ return smethod->iterator();
}
bool composite(Paint* target, CompositeMethod method)
cmpMethod = method;
return true;
}
+
+ bool rotate(float degree);
+ bool scale(float factor);
+ bool translate(float x, float y);
+ bool bounds(float* x, float* y, float* w, float* h, bool transformed);
+ void* update(RenderMethod& renderer, const RenderTransform* pTransform, uint32_t opacity, Array<RenderData>& clips, uint32_t pFlag);
+ bool render(RenderMethod& renderer);
+ Paint* duplicate();
};
PaintMethod(T* _inst) : inst(_inst) {}
~PaintMethod() {}
- bool bounds(float* x, float* y, float* w, float* h) const override
+ bool bounds(float* x, float* y, float* w, float* h) override
{
return inst->bounds(x, y, w, h);
}
return inst->dispose(renderer);
}
- void* update(RenderMethod& renderer, const RenderTransform* transform, uint32_t opacity, Array<RenderData>& clips, RenderUpdateFlag flag) override
+ void* update(RenderMethod& renderer, const RenderTransform* transform, uint32_t opacity, Array<RenderData>& clips, RenderUpdateFlag renderFlag) override
{
- return inst->update(renderer, transform, opacity, clips, flag);
+ return inst->update(renderer, transform, opacity, clips, renderFlag);
}
bool render(RenderMethod& renderer) override
{
return inst->duplicate();
}
+
+ Iterator* iterator() override
+ {
+ return inst->iterator();
+ }
};
}
projects / platform / core / graphics / tizenvg.git / blobdiff