pastk/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

removed unused classes and files from YG library.

Browse source
This commit is contained in:
rachytski 2011-07-07 01:11:56 +03:00 • committed by Alex Zolotarev
parent 055fc0b96a
commit 2f54dd7cf3
18 changed files with 6 additions and 883 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
map/render_queue_routine.hpp
View file

@ -7,7 +7,6 @@
#include "../geometry/screenbase.hpp"
#include "../std/list.hpp"
#include "../std/function.hpp"
#include "../yg/thread_renderer.hpp"
#include "../yg/color.hpp"
#include "../yg/tile_cache.hpp"
#include "../yg/tiler.hpp"

6
yg/clipper.hpp
View file

@ -1,17 +1,17 @@
#pragma once
#include "../geometry/rect2d.hpp"
#include "layer_manager.hpp"
#include "renderer.hpp"
namespace yg
{
namespace gl
{
class Clipper : public LayerManager
class Clipper : public Renderer
{
private:
typedef LayerManager base_t;
typedef Renderer base_t;
bool m_isClippingEnabled;
m2::RectI m_clipRect;

56
yg/fence.cpp
View file

@ -1,56 +0,0 @@
#include "../base/SRC_FIRST.hpp"
#include "fence.hpp"
#include "internal/opengl.hpp"
#include "../base/timer.hpp"
#include "../base/logging.hpp"
namespace yg
{
namespace gl
{
Fence::Fence() : m_inserted(false)
{
#if defined(OMIM_OS_MAC) && !defined(OMIM_GL_ES)
OGLCHECK(glGenFencesAPPLE(1, &m_id));
#endif
}
Fence::~Fence()
{
#if defined(OMIM_OS_MAC) && !defined(OMIM_GL_ES)
OGLCHECK(glDeleteFencesAPPLE(1, &m_id));
#endif
}
void Fence::insert()
{
if (!m_inserted)
{
#if defined(OMIM_OS_MAC) && !defined(OMIM_GL_ES)
OGLCHECK(glSetFenceAPPLE(m_id));
#endif
m_inserted = true;
}
}
bool Fence::status()
{
#if defined(OMIM_OS_MAC) && !defined(OMIM_GL_ES)
return glTestFenceAPPLE(m_id);
#else
return false;
#endif
}
void Fence::wait()
{
if (m_inserted)
{
#if defined(OMIM_OS_MAC) && !defined(OMIM_GL_ES)
OGLCHECK(glFinishFenceAPPLE(m_id));
#endif
m_inserted = false;
}
}
}
}

26
yg/fence.hpp
View file

@ -1,26 +0,0 @@
#pragma once
namespace yg
{
namespace gl
{
/// Synchronization mechanism
class Fence
{
private:
unsigned int m_id;
bool m_inserted;
public:
Fence();
~Fence();
/// insert fence in the opengl command stream
void insert();
/// wait until signaled
void wait();
/// get the completion status
/// true - fence reached
/// false - not reached
bool status();
};
}
}

1
yg/geometry_batcher.cpp
View file

@ -1,6 +1,5 @@
#include "geometry_batcher.hpp"
#include "skin.hpp"
#include "memento.hpp"
#include "color.hpp"
#include "utils.hpp"
#include "resource_manager.hpp"

6
yg/geometry_batcher.hpp
View file

@ -5,7 +5,7 @@
#include "indexbuffer.hpp"
#include "renderbuffer.hpp"
#include "framebuffer.hpp"
#include "render_state_updater.hpp"
#include "geometry_renderer.hpp"
#include "storage.hpp"
#include "skin_page.hpp"
@ -30,7 +30,7 @@ namespace yg
namespace gl
{
class GeometryBatcher : public RenderStateUpdater
class GeometryBatcher : public GeometryRenderer
{
public:
@ -38,7 +38,7 @@ namespace yg
private:
typedef RenderStateUpdater base_t;
typedef GeometryRenderer base_t;
shared_ptr<yg::Skin> m_skin;

55
yg/gpu_state.hpp
View file

@ -1,55 +0,0 @@
#pragma once
#include "internal/opengl.hpp"
namespace yg
{
namespace gl
{
struct ArrayParams
{
/// vertexArray params
bool m_enabled;
GLint m_size;
GLenum m_type;
GLsizei m_stride;
GLvoid * m_ptr;
};
class GPUState
{
private:
int m_readFBO;
int m_drawFBO;
int m_fboColor0;
int m_fboDepth;
int m_fboStencil;
int m_tex0;
int m_vb;
int m_ib;
ArrayParams m_vertexAP;
ArrayParams m_colorAP;
ArrayParams m_texCoordAP;
bool m_depthTest;
GLenum m_depthFunc;
bool m_alphaTest;
GLenum m_alphaFunc;
GLclampf m_ref;
bool m_alphaBlend;
GLenum m_srcFactor;
GLenum m_dstFactor;
yg::Color m_color;
public:
};
}
}

36
yg/layer_manager.cpp
View file

@ -1,36 +0,0 @@
#include "../base/SRC_FIRST.hpp"
#include "layer_manager.hpp"
namespace yg
{
namespace gl
{
LayerManager::LayerManager(base_t::Params const & params) : base_t(params)
{}
/* int LayerManager::addLayer(shared_ptr<BaseTexture> const & layer, m2::PointU const & org)
{
Layer l = {layer, org};
m_layers.push_back(l);
return m_layers.size() - 1;
}
void LayerManager::removeLayer(int idx)
{
TLayers::iterator it = m_layers.begin();
advance(it, idx);
m_layers.erase(it);
}
LayerManager::Layer const & LayerManager::layer(int idx) const
{
return m_layers[idx];
}
int LayerManager::layersCount() const
{
return m_layers.size();
}*/
}
}

48
yg/layer_manager.hpp
View file

@ -1,48 +0,0 @@
#pragma once
#include "renderer.hpp"
#include "../geometry/point2d.hpp"
#include "../std/vector.hpp"
namespace yg
{
namespace gl
{
class BaseTexture;
/// all the layers are combined by a simple blitting
/// at the endFrame/updateActualTarget.
class LayerManager : public Renderer
{
public:
struct Layer
{
shared_ptr<BaseTexture> m_surface;
m2::PointU m_org;
};
private:
typedef vector<Layer> TLayers;
TLayers m_layers;
public:
typedef Renderer base_t;
LayerManager(base_t::Params const & params);
/* /// adding composition layer. it's up to the higher levels
/// of the hierarchy to use this layers for composition.
int addLayer(shared_ptr<BaseTexture> const & layer, m2::PointU const & org = m2::PointU(0, 0));
/// remove layer from composition stack
void removeLayer(int idx);
/// get specific layer
Layer const & layer(int idx) const;
/// get layers count
int layersCount() const;*/
};
}
}

83
yg/memento.cpp
View file

@ -1,83 +0,0 @@
#include "memento.hpp"
#include "internal/opengl.hpp"
namespace yg
{
namespace gl
{
Memento::Memento()
{
m_isDepthTestEnabled = glIsEnabled(GL_DEPTH_TEST);
OGLCHECK(glGetIntegerv(GL_DEPTH_FUNC, &m_depthFunc));
OGLCHECK(glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &m_arrayBinding));
OGLCHECK(glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &m_elementArrayBinding));
OGLCHECK(glGetBooleanv(GL_TEXTURE_2D, (GLboolean*)&m_isTextureEnabled));
OGLCHECK(glGetIntegerv(GL_TEXTURE_BINDING_2D, &m_level0Texture));
OGLCHECK(glGetBooleanv(GL_VERTEX_ARRAY, (GLboolean*)&m_isVertexArrayEnabled));
OGLCHECK(glGetIntegerv(GL_VERTEX_ARRAY_TYPE, &m_vertexArrayType));
OGLCHECK(glGetIntegerv(GL_VERTEX_ARRAY_STRIDE, &m_vertexArrayStride));
OGLCHECK(glGetIntegerv(GL_VERTEX_ARRAY_SIZE, &m_vertexArraySize));
OGLCHECK(glGetPointerv(GL_VERTEX_ARRAY_POINTER, &m_vertexArrayPointer));
OGLCHECK(glGetBooleanv(GL_COLOR_ARRAY, (GLboolean*)&m_isColorArrayEnabled));
OGLCHECK(glGetIntegerv(GL_COLOR_ARRAY_TYPE, &m_colorArrayType));
OGLCHECK(glGetIntegerv(GL_COLOR_ARRAY_STRIDE, &m_colorArrayStride));
OGLCHECK(glGetIntegerv(GL_COLOR_ARRAY_SIZE, &m_colorArraySize));
OGLCHECK(glGetPointerv(GL_COLOR_ARRAY_POINTER, &m_colorArrayPointer));
OGLCHECK(glGetBooleanv(GL_TEXTURE_COORD_ARRAY, (GLboolean*)&m_isTexCoordArrayEnabled));
OGLCHECK(glGetIntegerv(GL_TEXTURE_COORD_ARRAY_TYPE, &m_texCoordArrayType));
OGLCHECK(glGetIntegerv(GL_TEXTURE_COORD_ARRAY_STRIDE, &m_texCoordArrayStride));
OGLCHECK(glGetIntegerv(GL_TEXTURE_COORD_ARRAY_SIZE, &m_texCoordArraySize));
OGLCHECK(glGetPointerv(GL_TEXTURE_COORD_ARRAY_POINTER, &m_texCoordArrayPointer));
}
void Memento::apply()
{
if (m_isDepthTestEnabled)
OGLCHECK(glEnable(GL_DEPTH_TEST));
else
OGLCHECK(glDisable(GL_DEPTH_TEST));
OGLCHECK(glDepthFunc(m_depthFunc));
OGLCHECK(glBindBuffer(GL_ARRAY_BUFFER, m_arrayBinding));
OGLCHECK(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_elementArrayBinding));
if (m_isTextureEnabled)
OGLCHECK(glEnable(GL_TEXTURE_2D));
else
OGLCHECK(glDisable(GL_TEXTURE_2D));
OGLCHECK(glBindTexture(GL_TEXTURE_2D, m_level0Texture));
if (m_isVertexArrayEnabled)
{
OGLCHECK(glEnableClientState(GL_VERTEX_ARRAY));
OGLCHECK(glVertexPointer(m_vertexArraySize, m_vertexArrayType, m_vertexArrayStride, m_vertexArrayPointer));
}
else
OGLCHECK(glDisableClientState(GL_VERTEX_ARRAY));
if (m_isColorArrayEnabled)
{
OGLCHECK(glEnableClientState(GL_COLOR_ARRAY));
OGLCHECK(glColorPointer(m_colorArraySize, m_colorArrayType, m_colorArrayStride, m_colorArrayPointer));
}
else
OGLCHECK(glDisableClientState(GL_COLOR_ARRAY));
if (m_isTexCoordArrayEnabled)
{
OGLCHECK(glEnableClientState(GL_TEXTURE_COORD_ARRAY));
OGLCHECK(glTexCoordPointer(m_texCoordArraySize, m_texCoordArrayType, m_texCoordArrayStride, m_texCoordArrayPointer));
}
else
OGLCHECK(glDisableClientState(GL_TEXTURE_COORD_ARRAY));
}
}
}

42
yg/memento.hpp
View file

@ -1,42 +0,0 @@
#pragma once
namespace yg
{
namespace gl
{
struct Memento
{
bool m_isDepthTestEnabled;
int m_depthFunc;
bool m_isVertexArrayEnabled;
int m_vertexArraySize;
int m_vertexArrayStride;
int m_vertexArrayType;
void * m_vertexArrayPointer;
bool m_isColorArrayEnabled;
int m_colorArraySize;
int m_colorArrayStride;
int m_colorArrayType;
void * m_colorArrayPointer;
bool m_isTexCoordArrayEnabled;
int m_texCoordArraySize;
int m_texCoordArrayStride;
int m_texCoordArrayType;
void * m_texCoordArrayPointer;
bool m_isTextureEnabled;
int m_level0Texture;
int m_arrayBinding;
int m_elementArrayBinding;
/// Save current states to memento.
Memento();
/// Apply states saved in this memento to the current state
void apply();
};
}
}

22
yg/render_command.cpp
View file

@ -1,22 +0,0 @@
#include "../base/SRC_FIRST.hpp"
#include "internal/opengl.hpp"
#include "render_command.hpp"
#include "vertexbuffer.hpp"
#include "indexbuffer.hpp"
#include "vertex.hpp"
#include "base_texture.hpp"
#include "blitter.hpp"
#include "../base/mutex.hpp"
namespace yg
{
namespace gl
{
void UpdateActualTarget::operator()()
{
}
}
}

56
yg/render_command.hpp
View file

@ -1,56 +0,0 @@
#pragma once
#include "../std/shared_ptr.hpp"
#include "../geometry/rect2d.hpp"
namespace yg
{
namespace gl
{
class VertexBuffer;
class IndexBuffer;
class BaseTexture;
class RenderState;
class Blitter;
struct PrepareBackBuffer
{
shared_ptr<RenderState> m_renderState;
shared_ptr<Blitter> m_blitter;
PrepareBackBuffer(shared_ptr<RenderState> const & renderState,
shared_ptr<Blitter> const & blitter);
void operator()();
};
struct DrawGeometry
{
m2::RectI m_viewport;
shared_ptr<BaseTexture> m_texture;
shared_ptr<VertexBuffer> m_vertices;
shared_ptr<IndexBuffer> m_indices;
size_t m_indicesCount;
DrawGeometry();
DrawGeometry(m2::RectI const & viewport,
shared_ptr<BaseTexture> const & texture,
shared_ptr<VertexBuffer> const & vertices,
shared_ptr<IndexBuffer> const & indices,
size_t indicesCount);
void operator()();
};
struct UpdateActualTarget
{
shared_ptr<RenderState> m_renderState;
shared_ptr<Blitter> m_blitter;
UpdateActualTarget(shared_ptr<RenderState> const & renderState,
shared_ptr<Blitter> const & blitter);
void operator()();
};
}
}

80
yg/render_state_updater.cpp
View file

@ -1,80 +0,0 @@
#include "render_state_updater.hpp"
#include "render_state.hpp"
#include "framebuffer.hpp"
#include "internal/opengl.hpp"
#include "base_texture.hpp"
#include "info_layer.hpp"
#include "../base/logging.hpp"
namespace yg
{
namespace gl
{
RenderStateUpdater::Params::Params()
: m_doPeriodicalUpdate(false), m_updateInterval(0.0)
{}
RenderStateUpdater::RenderStateUpdater(Params const & params)
: base_t(params),
m_renderState(params.m_renderState),
m_doPeriodicalUpdate(params.m_doPeriodicalUpdate),
m_updateInterval(params.m_updateInterval)
{
}
shared_ptr<RenderState> const & RenderStateUpdater::renderState() const
{
return m_renderState;
}
void RenderStateUpdater::drawGeometry(shared_ptr<BaseTexture> const & texture,
shared_ptr<VertexBuffer> const & vertices,
shared_ptr<IndexBuffer> const & indices,
size_t indicesCount)
{
base_t::drawGeometry(texture, vertices, indices, indicesCount);
m_indicesCount += indicesCount;
if (m_doPeriodicalUpdate
&& m_renderState
&& (m_indicesCount > 20000)
&& (m_updateTimer.ElapsedSeconds() > m_updateInterval))
{
updateActualTarget();
m_indicesCount %= 20000;
m_updateTimer.Reset();
}
}
void RenderStateUpdater::updateActualTarget()
{}
void RenderStateUpdater::beginFrame()
{
base_t::beginFrame();
m_indicesCount = 0;
m_updateTimer.Reset();
}
void RenderStateUpdater::setClipRect(m2::RectI const & rect)
{
if ((m_renderState) && (m_indicesCount))
{
updateActualTarget();
m_indicesCount = 0;
m_updateTimer.Reset();
}
base_t::setClipRect(rect);
}
void RenderStateUpdater::endFrame()
{
if (m_renderState)
updateActualTarget();
m_indicesCount = 0;
m_updateTimer.Reset();
base_t::endFrame();
}
}
}

52
yg/render_state_updater.hpp
View file

@ -1,52 +0,0 @@
#pragma once
#include "../std/shared_ptr.hpp"
#include "../base/timer.hpp"
#include "geometry_renderer.hpp"
namespace yg
{
namespace gl
{
class RenderState;
class RenderStateUpdater : public GeometryRenderer
{
private:
typedef GeometryRenderer base_t;
shared_ptr<RenderState> m_renderState;
int m_indicesCount;
bool m_doPeriodicalUpdate;
double m_updateInterval;
my::Timer m_updateTimer;
public:
struct Params : base_t::Params
{
bool m_doPeriodicalUpdate;
double m_updateInterval;
shared_ptr<RenderState> m_renderState;
Params();
};
RenderStateUpdater(Params const & params);
shared_ptr<RenderState> const & renderState() const;
void drawGeometry(shared_ptr<BaseTexture> const & texture,
shared_ptr<VertexBuffer> const & vertices,
shared_ptr<IndexBuffer> const & indices,
size_t indicesCount);
void beginFrame();
void endFrame();
void setClipRect(m2::RectI const & rect);
virtual void updateActualTarget();
};
}
}

236
yg/thread_renderer.cpp
View file

@ -1,236 +0,0 @@
#include "../base/SRC_FIRST.hpp"
#include "thread_renderer.hpp"
#include "framebuffer.hpp"
#include "blitter.hpp"
#include "rendercontext.hpp"
#include "renderbuffer.hpp"
#include "render_state.hpp"
#include "vertexbuffer.hpp"
#include "indexbuffer.hpp"
#include "vertex.hpp"
#include "../base/logging.hpp"
#include "../geometry/screenbase.hpp"
#include "../std/algorithm.hpp"
namespace yg
{
namespace gl
{
ThreadRenderer::ThreadRenderer()
{}
void ThreadRenderer::init(shared_ptr<RenderContext> const & /*renderContext*/,
shared_ptr<RenderState> const & /*renderState*/)
{
// m_renderContext = renderContext;
// m_renderState = renderState;
}
void ThreadRenderer::setupStates()
{
/* LOG(LINFO, ("initializing separate thread rendering"));
m_renderContext->makeCurrent();
m_blitter = make_shared_ptr(new Blitter());
m_blitter->setFrameBuffer(make_shared_ptr(new FrameBuffer()));
OGLCHECK(glEnable(GL_TEXTURE_2D));
OGLCHECK(glEnable(GL_DEPTH_TEST));
OGLCHECK(glDepthFunc(GL_LEQUAL));
OGLCHECK(glEnable(GL_ALPHA_TEST));
OGLCHECK(glAlphaFunc(GL_GREATER, 0));
OGLCHECK(glEnable(GL_BLEND));
OGLCHECK(glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA));
OGLCHECK(glColor4f(1.0f, 1.0f, 1.0f, 1.0f));
*/
}
void ThreadRenderer::prepareBackBuffer()
{
/* threads::MutexGuard guard(*m_renderState->m_mutex.get());
m_blitter->frameBuffer()->setRenderTarget(m_renderState->m_backBuffer);
m_blitter->beginFrame();
m_blitter->enableClipRect(true);
m_blitter->setClipRect(m2::RectI(0, 0, m_renderState->m_textureWidth, m_renderState->m_textureHeight));
m_blitter->clear();
m_blitter->setClipRect(m2::RectI(0, 0, m_renderState->m_surfaceWidth, m_renderState->m_surfaceHeight));
if (m_renderState->isPanning())
m_blitter->blit(
m_renderState->m_actualTarget,
m_renderState->m_actualScreen,
m_renderState->m_currentScreen
);
m_blitter->endFrame();
*/
}
void ThreadRenderer::beginFrame()
{
// m_blitter->beginFrame();
}
void ThreadRenderer::endFrame()
{
// m_blitter->endFrame();
}
void ThreadRenderer::setCurrentScreen(ScreenBase const & /*currentScreen*/)
{
/* LOG(LINFO, ("setCurrentScreen"));
/// this prevents the framework from flooding us with a bunch of RenderCommands with the same screen.
{
threads::MutexGuard guard(*m_renderState->m_mutex.get());
m_renderState->m_currentScreen = currentScreen;
}
*/
}
void ThreadRenderer::processResize()
{
/* LOG(LINFO, ("processResize"));
threads::MutexGuard guard(*m_renderState->m_mutex.get());
if (m_renderState->m_isResized)
{
size_t texW = m_renderState->m_textureWidth;
size_t texH = m_renderState->m_textureHeight;
m_renderState->m_backBuffer.reset();
m_renderState->m_backBuffer = make_shared_ptr(new yg::gl::RGBA8Texture(texW, texH));
m_renderState->m_depthBuffer.reset();
m_renderState->m_depthBuffer = make_shared_ptr(new yg::gl::RenderBuffer(texW, texH, true));
m_blitter->setRenderTarget(m_renderState->m_backBuffer);
m_blitter->setDepthBuffer(m_renderState->m_depthBuffer);
m_blitter->onSize(texW, texH);
m_renderState->m_actualTarget.reset();
m_renderState->m_actualTarget = make_shared_ptr(new yg::gl::RGBA8Texture(texW, texH));
m_blitter->setRenderTarget(m_renderState->m_actualTarget);
m_blitter->beginFrame();
m_blitter->clear();
m_blitter->endFrame();
m_blitter->setRenderTarget(m_renderState->m_backBuffer);
m_blitter->beginFrame();
m_blitter->clear();
m_blitter->endFrame();
m_renderState->m_doRepaintAll = true;
m_renderState->m_isResized = false;
}
*/
}
void ThreadRenderer::setViewport(m2::RectI const & /*viewport*/)
{
/* LOG(LINFO, ("setViewport:", viewport));
if (m_viewport != viewport)
{
m_viewport = viewport;
m_blitter->setClipRect(m_viewport);
// OGLCHECK(glScissor(m_viewport.minX(), m_viewport.minY(), m_viewport.maxX(), m_viewport.maxY()));
// m_viewport = viewport;
}
*/
}
void ThreadRenderer::blitBackBuffer()
{
/* LOG(LINFO, ("blitBackBuffer"));
m_blitter->enableClipRect(true);
m_blitter->setClipRect(m2::RectI(0, 0, m_renderStateCopy.m_textureWidth, m_renderStateCopy.m_textureHeight));
m_blitter->clear();
m_blitter->setClipRect(m2::RectI(0, 0, m_renderStateCopy.m_surfaceWidth, m_renderStateCopy.m_surfaceHeight));
if (m_renderStateCopy.isPanning())
m_blitter->blit(
m_renderStateCopy.m_actualTarget,
m_renderStateCopy.m_actualScreen,
m_renderStateCopy.m_currentScreen);
*/
}
void ThreadRenderer::drawGeometry(shared_ptr<BaseTexture> const & /*texture*/,
shared_ptr<VertexBuffer> const & /*vertices*/,
shared_ptr<IndexBuffer> const & /*indices*/,
size_t /*indicesCount*/)
{
/* LOG(LINFO, ("drawGeometry"));
if (m_texture != texture)
{
m_texture = texture;
m_texture->makeCurrent();
}
vertices->makeCurrent();
Vertex::setupLayout();
indices->makeCurrent();
OGLCHECK(glDrawElements(
GL_TRIANGLES,
indicesCount,
GL_UNSIGNED_SHORT,
0));
updateActualTarget();
*/
}
void ThreadRenderer::updateActualTarget()
{
/* LOG(LINFO, ("updateActualTarget"));
OGLCHECK(glFinish());
threads::MutexGuard guard(*m_renderState->m_mutex.get());
m_blitter->frameBuffer()->attachTexture(m_renderState->m_actualTarget);
OGLCHECK(glDisable(GL_SCISSOR_TEST));
OGLCHECK(glClearColor(192 / 255.0, 192 / 255.0, 192 / 255.0, 1.0));
OGLCHECK(glClear(GL_COLOR_BUFFER_BIT));
size_t w = m_renderState->m_backBuffer->width();
size_t h = m_renderState->m_backBuffer->height();
m_blitter->immDrawTexturedRect(
m2::RectF(0, 0, w, h),
m2::RectF(0, 0, 1, 1),
m_renderState->m_backBuffer
);
if (m_blitter->clipRectEnabled())
OGLCHECK(glEnable(GL_SCISSOR_TEST));
OGLCHECK(glFinish());
m_blitter->frameBuffer()->attachTexture(m_renderState->m_backBuffer);
*/
}
void ThreadRenderer::copyRenderState()
{
/* LOG(LINFO, ("copyRenderState"));
m_renderState->copyTo(m_renderStateCopy);
*/
}
}
}

70
yg/thread_renderer.hpp
View file

@ -1,70 +0,0 @@
#pragma once
#include "render_state.hpp"
#include "../geometry/rect2d.hpp"
#include "../std/shared_ptr.hpp"
class ScreenBase;
namespace yg
{
namespace gl
{
class BaseTexture;
class RenderContext;
class FrameBuffer;
class RenderBuffer;
class RenderState;
class Blitter;
class IndexBuffer;
class VertexBuffer;
class ThreadRenderer
{
private:
shared_ptr<RenderContext> m_renderContext;
shared_ptr<RenderState> m_renderState;
shared_ptr<Blitter> m_blitter;
RenderState m_renderStateCopy;
/// Current states
shared_ptr<BaseTexture> m_texture;
m2::RectI m_viewport;
public:
ThreadRenderer();
void init(shared_ptr<RenderContext> const & renderContext,
shared_ptr<RenderState> const & renderState);
void setupStates();
void prepareBackBuffer();
void beginFrame();
void endFrame();
void setCurrentScreen(ScreenBase const & currentScreen);
void processResize();
void setViewport(m2::RectI const & viewport);
void drawGeometry(shared_ptr<BaseTexture> const & texture,
shared_ptr<VertexBuffer> const & vertices,
shared_ptr<IndexBuffer> const & indices,
size_t indicesCount);
void updateActualTarget();
void blitBackBuffer();
void copyRenderState();
};
}
}

13
yg/yg.pro
View file

@ -25,7 +25,6 @@ SOURCES += \
resource_style.cpp \
color.cpp \
skin_loader.cpp \
memento.cpp \
framebuffer.cpp \
vertexbuffer.cpp \
indexbuffer.cpp \
@ -33,9 +32,6 @@ SOURCES += \
renderbuffer.cpp \
base_texture.cpp \
managed_texture.cpp \
fence.cpp \
thread_renderer.cpp \
render_command.cpp \
blitter.cpp \
clipper.cpp \
renderer.cpp \
@ -43,13 +39,11 @@ SOURCES += \
geometry_renderer.cpp \
skin_page.cpp \
storage.cpp \
render_state_updater.cpp \
glyph_cache.cpp \
glyph_cache_impl.cpp \
ft2_debug.cpp \
geometry_batcher.cpp \
text_renderer.cpp \
layer_manager.cpp \
path_renderer.cpp \
shape_renderer.cpp \
circle_info.cpp \
@ -75,7 +69,6 @@ HEADERS += \
pen_info.hpp \
resource_style.hpp \
color.hpp \
memento.hpp \
framebuffer.hpp \
vertexbuffer.hpp \
indexbuffer.hpp \
@ -83,10 +76,7 @@ HEADERS += \
renderbuffer.hpp \
base_texture.hpp \
managed_texture.hpp \
fence.hpp \
thread_renderer.hpp \
rendercontext.hpp \
render_command.hpp \
blitter.hpp \
clipper.hpp \
renderer.hpp \
@ -94,7 +84,6 @@ HEADERS += \
geometry_renderer.hpp \
skin_page.hpp \
storage.hpp \
render_state_updater.hpp \
render_target.hpp \
glyph_cache.hpp \
data_formats.hpp \
@ -103,8 +92,6 @@ HEADERS += \
text_renderer.hpp \
geometry_batcher.hpp \
screen.hpp \
layer_manager.hpp \
gpu_state.hpp \
defines.hpp \
path_renderer.hpp \
shape_renderer.hpp \