enum class TIZENVG_EXPORT PathCommand { Close, MoveTo, LineTo, CubicTo };
-class RasterMethod;
+class RenderMethod;
struct Point
{
{
public:
virtual ~PaintNode() {}
- virtual int dispose(RasterMethod* engine) = 0;
- virtual int update(RasterMethod* engine) = 0;
+ virtual int dispose(RenderMethod* engine) = 0;
+ virtual int update(RenderMethod* engine) = 0;
};
public:
~ShapeNode();
- int dispose(RasterMethod* engine) noexcept override;
- int update(RasterMethod* engine) noexcept override;
+ int dispose(RenderMethod* engine) noexcept override;
+ int update(RenderMethod* engine) noexcept override;
int clear() noexcept;
int appendRect(float x, float y, float w, float h, float radius) noexcept;
public:
~SceneNode();
- int dispose(RasterMethod* engine) noexcept override;
- int update(RasterMethod* engine) noexcept override;
+ int dispose(RenderMethod* engine) noexcept override;
+ int update(RenderMethod* engine) noexcept override;
int push(std::unique_ptr<ShapeNode> shape) noexcept;
int update() noexcept;
int draw(bool async = true) noexcept;
int sync() noexcept;
- RasterMethod* engine() noexcept;
+ RenderMethod* engine() noexcept;
int target(uint32_t* buffer, size_t stride, size_t height) noexcept;
int update() noexcept;
int draw(bool async = true) noexcept { return 0; }
int sync() noexcept { return 0; }
- RasterMethod* engine() noexcept;
+ RenderMethod* engine() noexcept;
static std::unique_ptr<GlCanvas> gen() noexcept;
source_file = [
- 'tvgGlEngine.h',
- 'tvgGlEngine.cpp',
+ 'tvgGlRenderer.h',
+ 'tvgGlRenderer.cpp',
]
glraster_dep = declare_dependency(
* limitations under the License.
*
*/
-#ifndef _TVG_GL_ENGINE_CPP_
-#define _TVG_GL_ENGINE_CPP_
+#ifndef _TVG_GL_RENDERER_CPP_
+#define _TVG_GL_RENDERER_CPP_
#include "tvgCommon.h"
-#include "tvgGlEngine.h"
+#include "tvgGlRenderer.h"
/************************************************************************/
/* Internal Class Implementation */
/************************************************************************/
-static RasterMethodInit engineInit;
+static RenderMethodInit engineInit;
struct GlShape
{
/* External Class Implementation */
/************************************************************************/
-void* GlEngine::dispose(const ShapeNode& shape, void *data)
+void* GlRenderer::dispose(const ShapeNode& shape, void *data)
{
GlShape* sdata = static_cast<GlShape*>(data);
if (!sdata) return nullptr;
}
-void* GlEngine::prepare(const ShapeNode& shape, void* data, UpdateFlag flags)
+void* GlRenderer::prepare(const ShapeNode& shape, void* data, UpdateFlag flags)
{
//prepare shape data
GlShape* sdata = static_cast<GlShape*>(data);
}
-int GlEngine::init()
+int GlRenderer::init()
{
- return RasterMethodInit::init(engineInit, new GlEngine);
+ return RenderMethodInit::init(engineInit, new GlRenderer);
}
-int GlEngine::term()
+int GlRenderer::term()
{
- return RasterMethodInit::term(engineInit);
+ return RenderMethodInit::term(engineInit);
}
-size_t GlEngine::unref()
+size_t GlRenderer::unref()
{
- return RasterMethodInit::unref(engineInit);
+ return RenderMethodInit::unref(engineInit);
}
-size_t GlEngine::ref()
+size_t GlRenderer::ref()
{
- return RasterMethodInit::ref(engineInit);
+ return RenderMethodInit::ref(engineInit);
}
-GlEngine* GlEngine::inst()
+GlRenderer* GlRenderer::inst()
{
- return dynamic_cast<GlEngine*>(RasterMethodInit::inst(engineInit));
+ return dynamic_cast<GlRenderer*>(RenderMethodInit::inst(engineInit));
}
-#endif /* _TVG_GL_ENGINE_CPP_ */
+#endif /* _TVG_GL_RENDERER_CPP_ */
* limitations under the License.
*
*/
-#ifndef _TVG_GL_ENGINE_H_
-#define _TVG_GL_ENGINE_H_
+#ifndef _TVG_GL_RENDERER_H_
+#define _TVG_GL_RENDERER_H_
namespace tvg
{
-class GlEngine : public RasterMethod
+class GlRenderer : public RenderMethod
{
public:
void* prepare(const ShapeNode& shape, void* data, UpdateFlag flags) override;
size_t ref() override;
size_t unref() override;
- static GlEngine* inst();
+ static GlRenderer* inst();
static int init();
static int term();
private:
- GlEngine(){};
- ~GlEngine(){};
+ GlRenderer(){};
+ ~GlRenderer(){};
};
}
-#endif /* _TVG_GL_ENGINE_H_ */
+#endif /* _TVG_GL_RENDERER_H_ */
source_file = [
'tvgSwCommon.h',
- 'tvgSwEngine.h',
- 'tvgSwEngine.cpp',
+ 'tvgSwRenderer.h',
+ 'tvgSwRenderer.cpp',
'tvgSwShape.cpp',
'tvgSwRle.cpp',
]
* limitations under the License.
*
*/
-#ifndef _TVG_SW_ENGINE_CPP_
-#define _TVG_SW_ENGINE_CPP_
+#ifndef _TVG_SW_RENDERER_CPP_
+#define _TVG_SW_RENDERER_CPP_
#include "tvgSwCommon.h"
-#include "tvgSwEngine.h"
+#include "tvgSwRenderer.h"
/************************************************************************/
/* Internal Class Implementation */
/************************************************************************/
-static RasterMethodInit engineInit;
+static RenderMethodInit engineInit;
/************************************************************************/
/* External Class Implementation */
/************************************************************************/
-void* SwEngine::dispose(const ShapeNode& shape, void *data)
+void* SwRenderer::dispose(const ShapeNode& shape, void *data)
{
SwShape* sdata = static_cast<SwShape*>(data);
if (!sdata) return nullptr;
return nullptr;
}
-void* SwEngine::prepare(const ShapeNode& shape, void* data, UpdateFlag flags)
+void* SwRenderer::prepare(const ShapeNode& shape, void* data, UpdateFlag flags)
{
//prepare shape data
SwShape* sdata = static_cast<SwShape*>(data);
}
-int SwEngine::init()
+int SwRenderer::init()
{
- return RasterMethodInit::init(engineInit, new SwEngine);
+ return RenderMethodInit::init(engineInit, new SwRenderer);
}
-int SwEngine::term()
+int SwRenderer::term()
{
- return RasterMethodInit::term(engineInit);
+ return RenderMethodInit::term(engineInit);
}
-size_t SwEngine::unref()
+size_t SwRenderer::unref()
{
- return RasterMethodInit::unref(engineInit);
+ return RenderMethodInit::unref(engineInit);
}
-size_t SwEngine::ref()
+size_t SwRenderer::ref()
{
- return RasterMethodInit::ref(engineInit);
+ return RenderMethodInit::ref(engineInit);
}
-SwEngine* SwEngine::inst()
+SwRenderer* SwRenderer::inst()
{
- return dynamic_cast<SwEngine*>(RasterMethodInit::inst(engineInit));
+ return dynamic_cast<SwRenderer*>(RenderMethodInit::inst(engineInit));
}
-#endif /* _TVG_SW_ENGINE_CPP_ */
+#endif /* _TVG_SW_RENDERER_CPP_ */
* limitations under the License.
*
*/
-#ifndef _TVG_SW_ENGINE_H_
-#define _TVG_SW_ENGINE_H_
+#ifndef _TVG_SW_RENDERER_H_
+#define _TVG_SW_RENDERER_H_
-class SwEngine : public RasterMethod
+class SwRenderer : public RenderMethod
{
public:
void* prepare(const ShapeNode& shape, void* data, UpdateFlag flags) override;
size_t ref() override;
size_t unref() override;
- static SwEngine* inst();
+ static SwRenderer* inst();
static int init();
static int term();
private:
- SwEngine(){};
- ~SwEngine(){};
+ SwRenderer(){};
+ ~SwRenderer(){};
};
-#endif /* _TVG_SW_ENGINE_H_ */
+#endif /* _TVG_SW_RENDERER_H_ */
struct CanvasBase
{
vector<PaintNode*> nodes;
- RasterMethod* raster;
+ RenderMethod* renderer;
- CanvasBase(RasterMethod *pRaster):raster(pRaster)
+ CanvasBase(RenderMethod *pRenderer):renderer(pRenderer)
{
- raster->ref();
+ renderer->ref();
}
~CanvasBase()
{
clear();
- raster->unref();
+ renderer->unref();
}
int reserve(size_t n)
int clear()
{
for (auto node : nodes) {
- node->dispose(raster);
+ node->dispose(renderer);
delete(node);
}
nodes.clear();
if (SceneNode *scene = dynamic_cast<SceneNode *>(node)) {
} else if (ShapeNode *shape = dynamic_cast<ShapeNode *>(node)) {
- return shape->update(raster);
+ return shape->update(renderer);
}
#else
if (ShapeNode *shape = dynamic_cast<ShapeNode *>(node)) {
- return shape->update(raster);
+ return shape->update(renderer);
}
#endif
cout << "What type of PaintNode? = " << node << endl;
namespace tvg
{
-class RasterMethod
+class RenderMethod
{
public:
enum UpdateFlag { None = 0, Path = 1, Fill = 2, All = 3 };
- virtual ~RasterMethod() {}
+ virtual ~RenderMethod() {}
virtual void* prepare(const ShapeNode& shape, void* data, UpdateFlag flags) = 0;
virtual void* dispose(const ShapeNode& shape, void *data) = 0;
virtual size_t ref() = 0;
virtual size_t unref() = 0;
};
-struct RasterMethodInit
+struct RenderMethodInit
{
- RasterMethod* pInst = nullptr;
+ RenderMethod* pInst = nullptr;
size_t refCnt = 0;
bool initted = false;
- static int init(RasterMethodInit& initter, RasterMethod* engine)
+ static int init(RenderMethodInit& initter, RenderMethod* engine)
{
assert(engine);
if (initter.pInst || initter.refCnt > 0) return -1;
return 0;
}
- static int term(RasterMethodInit& initter)
+ static int term(RenderMethodInit& initter)
{
if (!initter.pInst || !initter.initted) return -1;
return 0;
}
- static size_t unref(RasterMethodInit& initter)
+ static size_t unref(RenderMethodInit& initter)
{
assert(initter.refCnt > 0);
--initter.refCnt;
return initter.refCnt;
}
- static RasterMethod* inst(RasterMethodInit& initter)
+ static RenderMethod* inst(RenderMethodInit& initter)
{
assert(initter.pInst);
return initter.pInst;
}
- static size_t ref(RasterMethodInit& initter)
+ static size_t ref(RenderMethodInit& initter)
{
return ++initter.refCnt;
}
#define _TVG_ENGINE_CPP_
#include "tvgCommon.h"
-#include "tvgSwEngine.h"
-#include "tvgGlEngine.h"
+#include "tvgSwRenderer.h"
+#include "tvgGlRenderer.h"
/************************************************************************/
/* Internal Class Implementation */
//TODO: Initialize Raster engines by configuration.
int ret = 0;
- ret |= SwEngine::init();
- ret |= GlEngine::init();
+ ret |= SwRenderer::init();
+ ret |= GlRenderer::init();
return ret;
}
int Engine::term() noexcept
{
int ret = 0;
- ret |= SwEngine::term();
- ret |= GlEngine::term();
+ ret |= SwRenderer::term();
+ ret |= GlRenderer::term();
return ret;
}
#include "tvgCommon.h"
#include "tvgCanvasBase.h"
-#include "tvgGlEngine.h"
+#include "tvgGlRenderer.h"
/************************************************************************/
/* Internal Class Implementation */
struct GlCanvas::Impl : CanvasBase
{
- Impl() : CanvasBase(GlEngine::inst()) {}
+ Impl() : CanvasBase(GlRenderer::inst()) {}
};
}
-RasterMethod* GlCanvas::engine() noexcept
+RenderMethod* GlCanvas::engine() noexcept
{
auto impl = pImpl.get();
assert(impl);
- return impl->raster;
+ return impl->renderer;
}
#endif /* _TVG_GLCANVAS_CPP_ */
}
-int SceneNode :: dispose(RasterMethod* engine) noexcept
+int SceneNode :: dispose(RenderMethod* engine) noexcept
{
return 0;
}
-int SceneNode :: update(RasterMethod* engine) noexcept
+int SceneNode :: update(RenderMethod* engine) noexcept
{
return 0;
}
-int ShapeNode :: dispose(RasterMethod* engine) noexcept
+int ShapeNode :: dispose(RenderMethod* engine) noexcept
{
auto impl = pImpl.get();
assert(impl);
}
-int ShapeNode :: update(RasterMethod* engine) noexcept
+int ShapeNode :: update(RenderMethod* engine) noexcept
{
auto impl = pImpl.get();
assert(impl);
- impl->edata = engine->prepare(*this, impl->edata, RasterMethod::UpdateFlag::All);
+ impl->edata = engine->prepare(*this, impl->edata, RenderMethod::UpdateFlag::All);
if (impl->edata) return 0;
return - 1;
}
#include "tvgCommon.h"
#include "tvgCanvasBase.h"
-#include "tvgSwEngine.h"
+#include "tvgSwRenderer.h"
/************************************************************************/
int stride = 0;
int height = 0;
- Impl() : CanvasBase(SwEngine::inst()) {}
+ Impl() : CanvasBase(SwRenderer::inst()) {}
};
}
-RasterMethod* SwCanvas::engine() noexcept
+RenderMethod* SwCanvas::engine() noexcept
{
auto impl = pImpl.get();
assert(impl);
- return impl->raster;
+ return impl->renderer;
}
#endif /* _TVG_SWCANVAS_CPP_ */