diff options
27 files changed, 387 insertions, 288 deletions
diff --git a/drape/attribute_provider.cpp b/drape/attribute_provider.cpp index 6c677ba7b6..df6274f03a 100644 --- a/drape/attribute_provider.cpp +++ b/drape/attribute_provider.cpp @@ -59,7 +59,7 @@ void AttributeProvider::Advance(uint16_t vertexCount) const BindingInfo & info = m_streams[i].m_binding; uint32_t offset = vertexCount * info.GetElementSize(); void * rawPointer = m_streams[i].m_data.GetRaw(); - m_streams[i].m_data = ReferencePoiner<void>((void *)(((uint8_t *)rawPointer) + offset)); + m_streams[i].m_data = MakeStackRefPointer((void *)(((uint8_t *)rawPointer) + offset)); } m_vertexCount -= vertexCount; @@ -67,7 +67,7 @@ void AttributeProvider::Advance(uint16_t vertexCount) void AttributeProvider::InitStream(uint8_t streamIndex, const BindingInfo &bindingInfo, - ReferencePoiner<void> data) + RefPointer<void> data) { ASSERT_LESS(streamIndex, GetStreamCount(), ()); AttributeStream s; diff --git a/drape/attribute_provider.hpp b/drape/attribute_provider.hpp index 050629377c..404e4a4b05 100644 --- a/drape/attribute_provider.hpp +++ b/drape/attribute_provider.hpp @@ -22,7 +22,7 @@ public: void InitStream(uint8_t streamIndex, const BindingInfo & bindingInfo, - ReferencePoiner<void> data); + RefPointer<void> data); private: int32_t m_vertexCount; @@ -30,7 +30,7 @@ private: struct AttributeStream { BindingInfo m_binding; - ReferencePoiner<void> m_data; + RefPointer<void> m_data; }; vector<AttributeStream> m_streams; #ifdef DEBUG diff --git a/drape/batcher.cpp b/drape/batcher.cpp index 1b40c7699b..3e1d77edb7 100644 --- a/drape/batcher.cpp +++ b/drape/batcher.cpp @@ -91,7 +91,7 @@ namespace }; } -Batcher::Batcher(ReferencePoiner<IBatchFlush> flushInterface) +Batcher::Batcher(RefPointer<IBatchFlush> flushInterface) : m_flushInterface(flushInterface) { } @@ -104,14 +104,14 @@ Batcher::~Batcher() } template <typename strategy> -void Batcher::InsertTriangles(const GLState & state, strategy s, ReferencePoiner<AttributeProvider> params) +void Batcher::InsertTriangles(const GLState & state, strategy s, RefPointer<AttributeProvider> params) { while (params->IsDataExists()) { uint16_t vertexCount = params->GetVertexCount(); uint16_t indexCount = s.GetIndexCount(vertexCount); - ReferencePoiner<VertexArrayBuffer> buffer = GetBuffer(state); + RefPointer<VertexArrayBuffer> buffer = GetBuffer(state); uint16_t availableVertexCount = buffer->GetAvailableVertexCount(); uint16_t availableIndexCount = buffer->GetAvailableIndexCount(); @@ -142,7 +142,7 @@ void Batcher::InsertTriangles(const GLState & state, strategy s, ReferencePoiner /// upload data from params to GPU buffers for (size_t i = 0; i < params->GetStreamCount(); ++i) { - ReferencePoiner<GLBuffer> streamBuffer = buffer->GetBuffer(params->GetBindingInfo(i)); + RefPointer<GLBuffer> streamBuffer = buffer->GetBuffer(params->GetBindingInfo(i)); streamBuffer->UploadData(params->GetRawPointer(i), vertexCount); } @@ -152,43 +152,45 @@ void Batcher::InsertTriangles(const GLState & state, strategy s, ReferencePoiner } } -void Batcher::InsertTriangleList(const GLState & state, ReferencePoiner<AttributeProvider> params) +void Batcher::InsertTriangleList(const GLState & state, RefPointer<AttributeProvider> params) { InsertTriangles(state, TrianglesListStrategy(), params); } -void Batcher::InsertTriangleStrip(const GLState & state, ReferencePoiner<AttributeProvider> params) +void Batcher::InsertTriangleStrip(const GLState & state, RefPointer<AttributeProvider> params) { InsertTriangles(state, TrianglesStripStrategy(), params); } -void Batcher::InsertTriangleFan(const GLState & state, ReferencePoiner<AttributeProvider> params) +void Batcher::InsertTriangleFan(const GLState & state, RefPointer<AttributeProvider> params) { InsertTriangles(state, TrianglesFanStrategy(), params); } -ReferencePoiner<VertexArrayBuffer> Batcher::GetBuffer(const GLState & state) +RefPointer<VertexArrayBuffer> Batcher::GetBuffer(const GLState & state) { buckets_t::iterator it = m_buckets.find(state); if (it != m_buckets.end()) - return it->second.GetWeakPointer(); + return it->second.GetRefPointer(); - OwnedPointer<VertexArrayBuffer> buffer(new VertexArrayBuffer(768, 512)); + MasterPointer<VertexArrayBuffer> buffer(new VertexArrayBuffer(768, 512)); m_buckets.insert(make_pair(state, buffer)); - return buffer.GetWeakPointer(); + return buffer.GetRefPointer(); } void Batcher::FinalizeBuffer(const GLState & state) { + ///@TODO ASSERT(m_buckets.find(state) != m_buckets.end(), ("Have no bucket for finalize with given state")); - m_flushInterface->FlushFullBucket(state, m_buckets[state]); + m_flushInterface->FlushFullBucket(state, m_buckets[state].Move()); m_buckets.erase(state); } void Batcher::Flush() { - for (buckets_t::const_iterator it = m_buckets.begin(); it != m_buckets.end(); ++it) - m_flushInterface->FlushFullBucket(it->first, it->second); + ///@TODO + for (buckets_t::iterator it = m_buckets.begin(); it != m_buckets.end(); ++it) + m_flushInterface->FlushFullBucket(it->first, it->second.Move()); m_buckets.clear(); } diff --git a/drape/batcher.hpp b/drape/batcher.hpp index dc3b0e83b3..c94c7eb4d1 100644 --- a/drape/batcher.hpp +++ b/drape/batcher.hpp @@ -1,5 +1,6 @@ #pragma once +#include "pointers.hpp" #include "glstate.hpp" #include "vertex_array_buffer.hpp" #include "attribute_provider.hpp" @@ -11,33 +12,33 @@ class IBatchFlush public: virtual ~IBatchFlush() {} - virtual void FlushFullBucket(const GLState & state, OwnedPointer<VertexArrayBuffer> backet) = 0; + virtual void FlushFullBucket(const GLState & state, TransferPointer<VertexArrayBuffer> backet) = 0; }; class Batcher { public: - Batcher(ReferencePoiner<IBatchFlush> flushInterface); + Batcher(RefPointer<IBatchFlush> flushInterface); ~Batcher(); - void InsertTriangleList(const GLState & state, ReferencePoiner<AttributeProvider> params); - void InsertTriangleStrip(const GLState & state, ReferencePoiner<AttributeProvider> params); - void InsertTriangleFan(const GLState & state, ReferencePoiner<AttributeProvider> params); + void InsertTriangleList(const GLState & state, RefPointer<AttributeProvider> params); + void InsertTriangleStrip(const GLState & state, RefPointer<AttributeProvider> params); + void InsertTriangleFan(const GLState & state, RefPointer<AttributeProvider> params); void Flush(); private: template <typename strategy> - void InsertTriangles(const GLState & state, strategy s, ReferencePoiner<AttributeProvider> params); + void InsertTriangles(const GLState & state, strategy s, RefPointer<AttributeProvider> params); - ReferencePoiner<VertexArrayBuffer> GetBuffer(const GLState & state); + RefPointer<VertexArrayBuffer> GetBuffer(const GLState & state); /// return true if GLBuffer is finished - bool UploadBufferData(ReferencePoiner<GLBuffer> vertexBuffer, ReferencePoiner<AttributeProvider> params); + bool UploadBufferData(RefPointer<GLBuffer> vertexBuffer, RefPointer<AttributeProvider> params); void FinalizeBuffer(const GLState & state); private: - ReferencePoiner<IBatchFlush> m_flushInterface; + RefPointer<IBatchFlush> m_flushInterface; private: - typedef map<GLState, OwnedPointer<VertexArrayBuffer> > buckets_t; + typedef map<GLState, MasterPointer<VertexArrayBuffer> > buckets_t; buckets_t m_buckets; }; diff --git a/drape/drape_common.pri b/drape/drape_common.pri index b298e2476c..07ce3e79e0 100644 --- a/drape/drape_common.pri +++ b/drape/drape_common.pri @@ -9,7 +9,7 @@ SOURCES += \ $$DRAPE_DIR/vertex_array_buffer.cpp \ $$DRAPE_DIR/uniform_value.cpp \ $$DRAPE_DIR/texture.cpp \ - $$DRAPE_DIR/shader_reference.cpp \ + $$DRAPE_DIR/shader.cpp \ $$DRAPE_DIR/index_buffer.cpp \ $$DRAPE_DIR/gpu_program.cpp \ $$DRAPE_DIR/gpu_program_manager.cpp \ @@ -28,7 +28,7 @@ HEADERS += \ $$DRAPE_DIR/vertex_array_buffer.hpp \ $$DRAPE_DIR/uniform_value.hpp \ $$DRAPE_DIR/texture.hpp \ - $$DRAPE_DIR/shader_reference.hpp \ + $$DRAPE_DIR/shader.hpp \ $$DRAPE_DIR/pointers.hpp \ $$DRAPE_DIR/index_buffer.hpp \ $$DRAPE_DIR/gpu_program.hpp \ diff --git a/drape/drape_tests/attribute_provides_tests.cpp b/drape/drape_tests/attribute_provides_tests.cpp index a7d339effe..bee540bcf1 100644 --- a/drape/drape_tests/attribute_provides_tests.cpp +++ b/drape/drape_tests/attribute_provides_tests.cpp @@ -29,7 +29,7 @@ UNIT_TEST(InitStreamsTest) decl.m_componentType = GLConst::GLFloatType; decl.m_offset = 0; decl.m_stride = 0; - provider.InitStream(0, zeroStreamBinding, ReferencePoiner<void>(positions)); + provider.InitStream(0, zeroStreamBinding, MakeStackRefPointer(positions)); } { @@ -40,7 +40,7 @@ UNIT_TEST(InitStreamsTest) decl.m_componentType = GLConst::GLFloatType; decl.m_offset = 0; decl.m_stride = 0; - provider.InitStream(1, firstStreamBinding, ReferencePoiner<void>(depth)); + provider.InitStream(1, firstStreamBinding, MakeStackRefPointer(depth)); } { @@ -51,7 +51,7 @@ UNIT_TEST(InitStreamsTest) decl.m_componentType = GLConst::GLFloatType; decl.m_offset = 0; decl.m_stride = 0; - provider.InitStream(2, secondStreamBinding, ReferencePoiner<void>(normals)); + provider.InitStream(2, secondStreamBinding, MakeStackRefPointer(normals)); } TEST_EQUAL(provider.IsDataExists(), true, ()); @@ -114,7 +114,7 @@ UNIT_TEST(InterleavedStreamTest) decl.m_stride = 5 * sizeof(float); } - provider.InitStream(0, binding, ReferencePoiner<void>(data)); + provider.InitStream(0, binding, MakeStackRefPointer(data)); TEST_EQUAL(provider.IsDataExists(), true, ()); TEST_EQUAL(provider.GetVertexCount(), 10, ()); @@ -167,7 +167,7 @@ UNIT_TEST(MixedStreamsTest) decl.m_stride = 3 * sizeof(float); } - provider.InitStream(0, binding, ReferencePoiner<void>(position)); + provider.InitStream(0, binding, MakeStackRefPointer(position)); } { @@ -178,7 +178,7 @@ UNIT_TEST(MixedStreamsTest) decl.m_componentType = GLConst::GLFloatType; decl.m_offset = 0; decl.m_stride = 0; - provider.InitStream(1, binding, ReferencePoiner<void>(normal)); + provider.InitStream(1, binding, MakeStackRefPointer(normal)); } TEST_EQUAL(provider.IsDataExists(), true, ()); diff --git a/drape/drape_tests/batcher_tests.cpp b/drape/drape_tests/batcher_tests.cpp index 1b7752bbbc..861a102a1a 100644 --- a/drape/drape_tests/batcher_tests.cpp +++ b/drape/drape_tests/batcher_tests.cpp @@ -20,19 +20,20 @@ namespace class VAOAcceptor : public IBatchFlush { public: - VAOAcceptor(ReferencePoiner<GpuProgram> program) + VAOAcceptor(RefPointer<GpuProgram> program) : m_program(program) { } - virtual void FlushFullBucket(const GLState & state, OwnedPointer<VertexArrayBuffer> bucket) + virtual void FlushFullBucket(const GLState & state, TransferPointer<VertexArrayBuffer> bucket) { - bucket->Build(m_program); - bucket.Destroy(); + MasterPointer<VertexArrayBuffer> masterBucket(bucket); + masterBucket->Build(m_program); + masterBucket.Destroy(); } private: - ReferencePoiner<GpuProgram> m_program; + RefPointer<GpuProgram> m_program; }; struct MemoryComparer @@ -98,7 +99,7 @@ UNIT_TEST(BatchLists_Test) GpuProgramManager * pm = new GpuProgramManager(); VAOAcceptor acceptor(pm->GetProgram(0)); - Batcher batcher(ReferencePoiner<IBatchFlush>((IBatchFlush *)&acceptor)); + Batcher batcher(RefPointer<IBatchFlush>(MakeStackRefPointer((IBatchFlush *)&acceptor))); { InSequence vaoSeq; @@ -144,7 +145,7 @@ UNIT_TEST(BatchLists_Test) EXPECTGL(glDeleteProgram(ProgramID)); } - GLState state(0, 0, TextureBinding("", false, 0, ReferencePoiner<Texture>(NULL))); + GLState state(0, 0, TextureBinding("", false, 0, RefPointer<Texture>())); BindingInfo binding(1); BindingDecl & decl = binding.GetBindingDecl(0); @@ -155,9 +156,9 @@ UNIT_TEST(BatchLists_Test) decl.m_stride = 0; AttributeProvider provider(1, 10); - provider.InitStream(0, binding, ReferencePoiner<void>(data)); + provider.InitStream(0, binding, MakeStackRefPointer(data)); - batcher.InsertTriangleList(state, ReferencePoiner<AttributeProvider>(&provider)); + batcher.InsertTriangleList(state, MakeStackRefPointer(&provider)); batcher.Flush(); delete pm; diff --git a/drape/drape_tests/uniform_value_tests.cpp b/drape/drape_tests/uniform_value_tests.cpp index dff1cdd8e5..26199a3116 100644 --- a/drape/drape_tests/uniform_value_tests.cpp +++ b/drape/drape_tests/uniform_value_tests.cpp @@ -53,8 +53,8 @@ UNIT_TEST(UniformValueTest) const int32_t positionLoc = 10; const int32_t modelViewLoc = 11; - ShaderReference vertexShader("", ShaderReference::VertexShader); - ShaderReference fragmentShader("", ShaderReference::FragmentShader); + Shader vertexShader("", Shader::VertexShader); + Shader fragmentShader("", Shader::FragmentShader); float matrix[16] = { @@ -122,54 +122,54 @@ UNIT_TEST(UniformValueTest) EXPECTGL(glDeleteProgram(ProgramID)); } - GpuProgram * program = new GpuProgram(ReferencePoiner<ShaderReference>(&vertexShader), - ReferencePoiner<ShaderReference>(&fragmentShader)); + GpuProgram * program = new GpuProgram(MakeStackRefPointer(&vertexShader), + MakeStackRefPointer(&fragmentShader)); program->Bind(); { UniformValue v("position", 1); - v.Apply(ReferencePoiner<GpuProgram>(program)); + v.Apply(MakeStackRefPointer(program)); } { UniformValue v("position", 1, 2); - v.Apply(ReferencePoiner<GpuProgram>(program)); + v.Apply(MakeStackRefPointer(program)); } { UniformValue v("position", 1, 2, 3); - v.Apply(ReferencePoiner<GpuProgram>(program)); + v.Apply(MakeStackRefPointer(program)); } { UniformValue v("position", 1, 2, 3, 4); - v.Apply(ReferencePoiner<GpuProgram>(program)); + v.Apply(MakeStackRefPointer(program)); } { UniformValue v("position", 1.0f); - v.Apply(ReferencePoiner<GpuProgram>(program)); + v.Apply(MakeStackRefPointer(program)); } { UniformValue v("position", 1.0f, 2.0f); - v.Apply(ReferencePoiner<GpuProgram>(program)); + v.Apply(MakeStackRefPointer(program)); } { UniformValue v("position", 1.0f, 2.0f, 3.0f); - v.Apply(ReferencePoiner<GpuProgram>(program)); + v.Apply(MakeStackRefPointer(program)); } { UniformValue v("position", 1.0f, 2.0f, 3.0f, 4.0f); - v.Apply(ReferencePoiner<GpuProgram>(program)); + v.Apply(MakeStackRefPointer(program)); } { UniformValue v("viewModel", matrix); - v.Apply(ReferencePoiner<GpuProgram>(program)); + v.Apply(MakeStackRefPointer(program)); } delete program; diff --git a/drape/glstate.cpp b/drape/glstate.cpp index 634c114183..7417690b4c 100644 --- a/drape/glstate.cpp +++ b/drape/glstate.cpp @@ -33,7 +33,7 @@ vector<UniformValue> & GLState::GetUniformValues() return m_uniforms; } -void ApplyState(GLState state, ReferencePoiner<GpuProgram> program) +void ApplyState(GLState state, RefPointer<GpuProgram> program) { TextureBinding & binding = state.GetTextureBinding(); program->Bind(); diff --git a/drape/glstate.hpp b/drape/glstate.hpp index c0152bac0e..5b5fb68e16 100644 --- a/drape/glstate.hpp +++ b/drape/glstate.hpp @@ -32,4 +32,4 @@ private: vector<UniformValue> m_uniforms; }; -void ApplyState(GLState state, ReferencePoiner<GpuProgram> program); +void ApplyState(GLState state, RefPointer<GpuProgram> program); diff --git a/drape/gpu_program.cpp b/drape/gpu_program.cpp index 38264079db..6b1debe0a7 100644 --- a/drape/gpu_program.cpp +++ b/drape/gpu_program.cpp @@ -3,11 +3,8 @@ #include "../base/assert.hpp" -GpuProgram::GpuProgram(ReferencePoiner<ShaderReference> vertexShader, ReferencePoiner<ShaderReference> fragmentShader) +GpuProgram::GpuProgram(RefPointer<Shader> vertexShader, RefPointer<Shader> fragmentShader) { - vertexShader->Ref(); - fragmentShader->Ref(); - m_programID = GLFunctions::glCreateProgram(); GLFunctions::glAttachShader(m_programID, vertexShader->GetID()); GLFunctions::glAttachShader(m_programID, fragmentShader->GetID()); @@ -17,9 +14,6 @@ GpuProgram::GpuProgram(ReferencePoiner<ShaderReference> vertexShader, ReferenceP GLFunctions::glDetachShader(m_programID, vertexShader->GetID()); GLFunctions::glDetachShader(m_programID, fragmentShader->GetID()); - - vertexShader->Deref(); - fragmentShader->Deref(); } GpuProgram::~GpuProgram() diff --git a/drape/gpu_program.hpp b/drape/gpu_program.hpp index 74f7285bd2..99668b65bb 100644 --- a/drape/gpu_program.hpp +++ b/drape/gpu_program.hpp @@ -1,6 +1,6 @@ #pragma once -#include "shader_reference.hpp" +#include "shader.hpp" #include "pointers.hpp" #include "../std/string.hpp" @@ -8,8 +8,8 @@ class GpuProgram { public: - GpuProgram(ReferencePoiner<ShaderReference> vertexShader, - ReferencePoiner<ShaderReference> fragmentShader); + GpuProgram(RefPointer<Shader> vertexShader, + RefPointer<Shader> fragmentShader); ~GpuProgram(); void Bind(); diff --git a/drape/gpu_program_manager.cpp b/drape/gpu_program_manager.cpp index 13c3477666..9d379daa52 100644 --- a/drape/gpu_program_manager.cpp +++ b/drape/gpu_program_manager.cpp @@ -1,8 +1,9 @@ #include "gpu_program_manager.hpp" -#include "../base/assert.hpp" - #include "shader_def.hpp" +#include "../base/stl_add.hpp" +#include "../base/assert.hpp" + namespace { class ShaderMapper @@ -27,52 +28,40 @@ namespace static ShaderMapper s_mapper; } -GpuProgramManager::GpuProgramManager() -{ -} - GpuProgramManager::~GpuProgramManager() { - shader_map_t::iterator sit = m_shaders.begin(); - for (; sit != m_shaders.end(); ++sit) - { - sit->second->Deref(); - sit->second.Destroy(); - } - - program_map_t::iterator pit = m_programs.begin(); - for (; pit != m_programs.end(); ++pit) - pit->second.Destroy(); + GetRangeDeletor(m_programs, MasterPointerDeleter())(); + GetRangeDeletor(m_shaders, MasterPointerDeleter())(); } -ReferencePoiner<GpuProgram> GpuProgramManager::GetProgram(int index) +RefPointer<GpuProgram> GpuProgramManager::GetProgram(int index) { program_map_t::iterator it = m_programs.find(index); if (it != m_programs.end()) - return it->second.GetWeakPointer(); + return it->second.GetRefPointer(); gpu::ProgramInfo const & programInfo = s_mapper.GetShaders(index); - ReferencePoiner<ShaderReference> vertexShader = GetShader(programInfo.m_vertexIndex, - programInfo.m_vertexSource, - ShaderReference::VertexShader); - ReferencePoiner<ShaderReference> fragmentShader = GetShader(programInfo.m_fragmentIndex, - programInfo.m_fragmentSource, - ShaderReference::FragmentShader); + RefPointer<Shader> vertexShader = GetShader(programInfo.m_vertexIndex, + programInfo.m_vertexSource, + Shader::VertexShader); + RefPointer<Shader> fragmentShader = GetShader(programInfo.m_fragmentIndex, + programInfo.m_fragmentSource, + Shader::FragmentShader); - OwnedPointer<GpuProgram> p(new GpuProgram(vertexShader, fragmentShader)); - m_programs.insert(std::make_pair(index, p)); - return p.GetWeakPointer(); + MasterPointer<GpuProgram> & result = m_programs[index]; + result.Reset(new GpuProgram(vertexShader, fragmentShader)); + return result.GetRefPointer(); } -ReferencePoiner<ShaderReference> GpuProgramManager::GetShader(int index, const string & source, ShaderReference::Type t) +RefPointer<Shader> GpuProgramManager::GetShader(int index, const string & source, Shader::Type t) { shader_map_t::iterator it = m_shaders.find(index); if (it == m_shaders.end()) { - OwnedPointer<ShaderReference> r(new ShaderReference(source, t)); - r->Ref(); - m_shaders.insert(std::make_pair(index, r)); + MasterPointer<Shader> & shader = m_shaders[index]; + shader.Reset(new Shader(source, t)); + return shader.GetRefPointer(); } - - return m_shaders[index].GetWeakPointer(); + else + return it->second.GetRefPointer(); } diff --git a/drape/gpu_program_manager.hpp b/drape/gpu_program_manager.hpp index c97dc59dd2..91e2870895 100644 --- a/drape/gpu_program_manager.hpp +++ b/drape/gpu_program_manager.hpp @@ -2,7 +2,7 @@ #include "pointers.hpp" #include "gpu_program.hpp" -#include "shader_reference.hpp" +#include "shader.hpp" #include "../std/map.hpp" #include "../std/noncopyable.hpp" @@ -10,17 +10,16 @@ class GpuProgramManager : public noncopyable { public: - GpuProgramManager(); ~GpuProgramManager(); - ReferencePoiner<GpuProgram> GetProgram(int index); + RefPointer<GpuProgram> GetProgram(int index); private: - ReferencePoiner<ShaderReference> GetShader(int index, const string & source, ShaderReference::Type t); + RefPointer<Shader> GetShader(int index, const string & source, Shader::Type t); private: - typedef map<int, OwnedPointer<GpuProgram> > program_map_t; - typedef map<int, OwnedPointer<ShaderReference> > shader_map_t; + typedef map<int, MasterPointer<GpuProgram> > program_map_t; + typedef map<int, MasterPointer<Shader> > shader_map_t; program_map_t m_programs; shader_map_t m_shaders; }; diff --git a/drape/pointers.hpp b/drape/pointers.hpp index 5e0aa667de..12458b8b90 100644 --- a/drape/pointers.hpp +++ b/drape/pointers.hpp @@ -1,141 +1,261 @@ #pragma once -#include "../std/memcpy.hpp" +#include "../base/assert.hpp" -template <typename T> -class ReferencePoiner -{ -public: - ReferencePoiner() - : m_p(NULL) - { - } +#ifdef DEBUG + #include "../std/map.hpp" - ReferencePoiner(T * p) - : m_p(p) + template <typename T> + class PointerTracker { - } + public: + ~PointerTracker() + { + ASSERT(m_countMap.empty(), ()); + } - bool IsNull() const - { - return m_p == NULL; - } + void Ref(void * p) + { + if (p == NULL) + return; - T * operator ->() - { - return m_p; - } + ++m_countMap[p]; + int x = m_countMap[p]; + x++; + } + + void Deref(void * p) + { + if (p == NULL) + return; + + map_t::iterator it = m_countMap.find(p); + ASSERT(it != m_countMap.end(), ()); + ASSERT(it->second > 0, ()); + + it->second--; + int x = it->second; + x++; + if (it->second == 0) + m_countMap.erase(it); + } + + void Destroy(void * p) + { + if (p == NULL) + return; + + map_t::iterator it = m_countMap.find(p); + ASSERT(it != m_countMap.end(), ()); + int count = it->second; + if (count < 100) + ASSERT(it->second == 1, ()); + } + + private: + typedef map<void *, int> map_t; + map_t m_countMap; + }; + + #define DECLARE_TRACKER \ + static PointerTracker<T> m_tracker + #define IMPLEMENT_TRACKER template<typename T> PointerTracker<T> DrapePointer<T>::m_tracker + #define REF_POINTER(p) m_tracker.Ref(p) + #define DEREF_POINTER(p) m_tracker.Deref(p) + #define DESTROY_POINTER(p) m_tracker.Destroy(p) +#else + #define DECLARE_TRACKER + #define REF_POINTER(p) + #define DEREF_POINTER(p) + #define DESTROY_POINTER(p) + #define IMPLEMENT_TRACKER +#endif - const T * operator ->() const +template <typename T> +class DrapePointer +{ +public: + DrapePointer() : m_p(NULL) {} + +protected: + DrapePointer(T * p) : m_p(p) { - return m_p; + REF_POINTER(m_p); } - T * GetRaw() + DrapePointer(DrapePointer<T> const & other) { - return m_p; + m_p = other.m_p; + REF_POINTER(m_p); } - const T * GetRaw() const + DrapePointer<T> & operator = (DrapePointer<T> const & other) { - return m_p; + m_p = other.m_p; + REF_POINTER(m_p); + return *this; } - bool operator != (const ReferencePoiner<T> & other) const + void Destroy() { - return *m_p != *other.m_p; + DESTROY_POINTER(m_p); + delete m_p; + DEREF_POINTER(m_p); + m_p = NULL; } - bool operator < (const ReferencePoiner<T> & other) const + void Reset(T * p) { - return *m_p < *other.m_p; + DEREF_POINTER(m_p); + m_p = p; + REF_POINTER(m_p); } + T * GetRaw() { return m_p; } + T const * GetRaw() const { return m_p; } + T * GetNonConstRaw() const { return m_p; } + private: T * m_p; + DECLARE_TRACKER; }; +IMPLEMENT_TRACKER; + +template <typename T> class MasterPointer; + template <typename T> -class OwnedPointer +class TransferPointer : public DrapePointer<T> { + typedef DrapePointer<T> base_t; public: - OwnedPointer() - : m_p(NULL) - { - } + TransferPointer(const TransferPointer<T> & other) : base_t(other) {} - OwnedPointer(T * p) - : m_p(p) + TransferPointer<T> & operator= (TransferPointer<T> const & other) { + base_t::Reset(other.GetNonConstRaw()); + return *this; } - ~OwnedPointer() - { - } + void Destroy() { base_t::Destroy(); } - void Reset(T * p) - { - Destroy(); - m_p = p; - } +private: + friend class MasterPointer<T>; + TransferPointer() {} + TransferPointer(T * p) : base_t(p) {} +}; - void Destroy() - { - delete m_p; - m_p = NULL; - } +template <typename T> class RefPointer; +template <typename T> RefPointer<T> MakeStackRefPointer(T * p); + +template<typename T> +class RefPointer : public DrapePointer<T> +{ + typedef DrapePointer<T> base_t; +public: + RefPointer() : base_t() {} + RefPointer(const RefPointer<T> & p) : base_t(p.GetNonConstRaw()) {} + + template <typename Y> + RefPointer(const RefPointer<Y> & p) : base_t(p.GetNonConstRaw()) {} + ~RefPointer() { base_t::Reset(NULL); } - ReferencePoiner<T> GetWeakPointer() + RefPointer & operator = (const RefPointer<T> & other) { - return ReferencePoiner<T>(m_p); + base_t::Reset(other.GetNonConstRaw()); + return *this; } - const ReferencePoiner<T> GetWeakPointer() const + bool IsContentLess(RefPointer<T> const & other) const { - return ReferencePoiner<T>(m_p); + return *GetRaw() < *other.GetRaw(); } - template <typename U> - ReferencePoiner<U> GetWeakPointer() + bool IsNull() const { return base_t::GetRaw() == NULL; } + T * operator->() { return base_t::GetRaw(); } + T const * operator->() const { return base_t::GetRaw(); } + T * GetRaw() { return base_t::GetRaw(); } + T const * GetRaw() const { return base_t::GetRaw(); } + +private: + template <typename Y> friend class RefPointer; + friend class MasterPointer<T>; + friend RefPointer<T> MakeStackRefPointer<T>(T *); + RefPointer(T * p) : base_t(p) {} +}; + +template <typename T> +RefPointer<T> MakeStackRefPointer(T * p) +{ + return RefPointer<T>(p); +} + +template <typename T> +class MasterPointer : public DrapePointer<T> +{ + typedef DrapePointer<T> base_t; +public: + MasterPointer() : base_t() {} + MasterPointer(T * p) : base_t(p) {} + MasterPointer(TransferPointer<T> & transferPointer) { - return ReferencePoiner<U>(m_p); + Reset(transferPointer.GetRaw()); + transferPointer.Reset(NULL); } - bool IsNull() + ~MasterPointer() { - return m_p == NULL; + base_t::Reset(NULL); } - T * operator ->() + RefPointer<T> GetRefPointer() const { - return m_p; + return RefPointer<T>(base_t::GetNonConstRaw()); } - const T * operator ->() const + TransferPointer<T> Move() { - return m_p; + TransferPointer<T> result(GetRaw()); + base_t::Reset(NULL); + return result; } - T * GetRaw() + void Destroy() { - return m_p; + Reset(NULL); } - const T * GetRaw() const + void Reset(T * p) { - return m_p; + base_t::Destroy(); + base_t::Reset(p); } - bool operator != (const OwnedPointer<T> & other) const + bool IsNull() const { return base_t::GetRaw() == NULL; } + T * operator->() { return base_t::GetRaw(); } + T const * operator->() const { return base_t::GetRaw(); } + T * GetRaw() { return base_t::GetRaw(); } + T const * GetRaw() const { return base_t::GetRaw(); } +}; + +struct MasterPointerDeleter +{ + template <typename Y, typename T> + void operator() (pair<Y, MasterPointer<T> > & value) { - return *m_p != *other.m_p; + Destroy(value.second); } - bool operator < (const OwnedPointer<T> & other) const + template <typename T> + void operator() (MasterPointer<T> & value) { - return *m_p < *other.m_p; + Destroy(value); } private: - T * m_p; + template <typename T> + void Destroy(MasterPointer<T> & value) + { + value.Destroy(); + } }; diff --git a/drape/shader.cpp b/drape/shader.cpp new file mode 100644 index 0000000000..2e30b4f90c --- /dev/null +++ b/drape/shader.cpp @@ -0,0 +1,38 @@ +#include "shader.hpp" +#include "glfunctions.hpp" + +#include "../base/assert.hpp" + +namespace +{ + glConst convert(Shader::Type t) + { + if (t == Shader::VertexShader) + return GLConst::GLVertexShader; + + return GLConst::GLFragmentShader; + } +} + +Shader::Shader(const string & shaderSource, Type type) + : m_source(shaderSource) + , m_type(type) + , m_glID(0) + , m_refCount(0) +{ + m_glID = GLFunctions::glCreateShader(convert(m_type)); + GLFunctions::glShaderSource(m_glID, m_source); + string errorLog; + bool result = GLFunctions::glCompileShader(m_glID, errorLog); + CHECK(result, ("Shader compile error : ", errorLog)); +} + +Shader::~Shader() +{ + GLFunctions::glDeleteShader(m_glID); +} + +int Shader::GetID() const +{ + return m_glID; +} diff --git a/drape/shader_reference.hpp b/drape/shader.hpp index e05dede218..f268f84e4a 100644 --- a/drape/shader_reference.hpp +++ b/drape/shader.hpp @@ -3,7 +3,7 @@ #include "../std/string.hpp" #include "../std/stdint.hpp" -class ShaderReference +class Shader { public: enum Type @@ -12,11 +12,10 @@ public: FragmentShader }; - ShaderReference(const string & shaderSource, Type type); + Shader(const string & shaderSource, Type type); + ~Shader(); int GetID() const; - void Ref(); - void Deref(); private: const string m_source; diff --git a/drape/shader_reference.cpp b/drape/shader_reference.cpp deleted file mode 100644 index 526301e12c..0000000000 --- a/drape/shader_reference.cpp +++ /dev/null @@ -1,56 +0,0 @@ -#include "shader_reference.hpp" -#include "glfunctions.hpp" - -#include "../base/assert.hpp" - -namespace -{ - glConst convert(ShaderReference::Type t) - { - if (t == ShaderReference::VertexShader) - return GLConst::GLVertexShader; - - return GLConst::GLFragmentShader; - } -} - -ShaderReference::ShaderReference(const string & shaderSource, Type type) - : m_source(shaderSource) - , m_type(type) - , m_glID(0) - , m_refCount(0) -{ -} - -int ShaderReference::GetID() const -{ - return m_glID; -} - -void ShaderReference::Ref() -{ - /// todo atomic compare - if (m_refCount == 0) - { - m_glID = GLFunctions::glCreateShader(convert(m_type)); - GLFunctions::glShaderSource(m_glID, m_source); - string errorLog; - if (!GLFunctions::glCompileShader(m_glID, errorLog)) - ASSERT(false, ()); - } - - /// todo atomic inc - m_refCount++; -} - -void ShaderReference::Deref() -{ - /// todo atomic dec ref on shader and delete if ref == 0 - m_refCount--; - - if (m_refCount == 0) - { - GLFunctions::glDeleteShader(m_glID); - m_glID = 0; - } -} diff --git a/drape/texture.cpp b/drape/texture.cpp index 3e905ba61b..def0d7fdb7 100644 --- a/drape/texture.cpp +++ b/drape/texture.cpp @@ -54,7 +54,7 @@ void Texture::Init(const TextureInfo &info, void * data) TextureBinding::TextureBinding(const std::string & uniformName, bool isEnabled, uint8_t samplerBlock, - ReferencePoiner<Texture> texture) + RefPointer<Texture> texture) : m_uniformName(uniformName) , m_isEnabled(isEnabled) , m_samplerBlock(samplerBlock) @@ -87,7 +87,7 @@ void TextureBinding::SetIsEnabled(bool isEnabled) m_isEnabled = isEnabled; } -void TextureBinding::SetTexture(ReferencePoiner<Texture> texture) +void TextureBinding::SetTexture(RefPointer<Texture> texture) { m_texture = texture; } diff --git a/drape/texture.hpp b/drape/texture.hpp index 44507b9d5b..536d871504 100644 --- a/drape/texture.hpp +++ b/drape/texture.hpp @@ -57,24 +57,24 @@ private: class TextureBinding { public: - TextureBinding(const string & uniformName, bool isEnabled, uint8_t samplerBlock, ReferencePoiner<Texture> texture); + TextureBinding(const string & uniformName, bool isEnabled, uint8_t samplerBlock, RefPointer<Texture> texture); void Bind(int8_t uniformLocation); bool IsEnabled() const; const string & GetUniformName() const; void SetIsEnabled(bool isEnabled); - void SetTexture(ReferencePoiner<Texture> texture); + void SetTexture(RefPointer<Texture> texture); bool operator<(const TextureBinding & other) const { return m_isEnabled < other.m_isEnabled || m_samplerBlock < other.m_samplerBlock - || m_texture < other.m_texture; + || m_texture.IsContentLess(other.m_texture); } private: string m_uniformName; bool m_isEnabled; uint8_t m_samplerBlock; - ReferencePoiner<Texture> m_texture; + RefPointer<Texture> m_texture; }; diff --git a/drape/uniform_value.cpp b/drape/uniform_value.cpp index dd88c86c55..1854d4a9c0 100644 --- a/drape/uniform_value.cpp +++ b/drape/uniform_value.cpp @@ -149,7 +149,7 @@ UniformValue::UniformValue(const string & name, float * matrixValue) m_componentCount = 16; } -void UniformValue::Apply(ReferencePoiner<GpuProgram> program) +void UniformValue::Apply(RefPointer<GpuProgram> program) { uint8_t location = program->GetUniformLocation(m_name); switch (m_type) { diff --git a/drape/uniform_value.hpp b/drape/uniform_value.hpp index 1e7eaac48d..e1de0beecc 100644 --- a/drape/uniform_value.hpp +++ b/drape/uniform_value.hpp @@ -22,7 +22,7 @@ public: explicit UniformValue(const string & name, float * matrixValue); - void Apply(ReferencePoiner<GpuProgram> program); + void Apply(RefPointer<GpuProgram> program); bool operator<(const UniformValue & other) const { diff --git a/drape/utils/list_generator.cpp b/drape/utils/list_generator.cpp index d0cafd4bf1..d1c8caa1e8 100644 --- a/drape/utils/list_generator.cpp +++ b/drape/utils/list_generator.cpp @@ -90,9 +90,10 @@ void ListGenerator::Generate(int count, Batcher & batcher) decl.m_componentType = GLConst::GLFloatType; decl.m_offset = 0; decl.m_stride = 0; - provider.InitStream(0, info, &vertexes[0]); + provider.InitStream(0, info, MakeStackRefPointer(&vertexes[0])); } + vector<float> depthMemory(vertexCount, m_depth); { BindingInfo info(1); BindingDecl & decl = info.GetBindingDecl(0); @@ -101,12 +102,11 @@ void ListGenerator::Generate(int count, Batcher & batcher) decl.m_componentType = GLConst::GLFloatType; decl.m_offset = 0; decl.m_stride = 0; - vector<float> depthMemory(vertexCount, m_depth); - provider.InitStream(1, info, &depthMemory[0]); + provider.InitStream(1, info, MakeStackRefPointer(&depthMemory[0])); } - TextureBinding textureBinding("", false, 0, ReferencePoiner<Texture>(NULL)); + TextureBinding textureBinding("", false, 0, RefPointer<Texture>()); GLState state(m_programIndex, (int16_t)m_depth, textureBinding); state.GetUniformValues() = m_uniforms; - batcher.InsertTriangleList(state, &provider); + batcher.InsertTriangleList(state, MakeStackRefPointer(&provider)); } diff --git a/drape/vertex_array_buffer.cpp b/drape/vertex_array_buffer.cpp index 5533187a18..d3b3116faa 100644 --- a/drape/vertex_array_buffer.cpp +++ b/drape/vertex_array_buffer.cpp @@ -2,12 +2,13 @@ #include "glfunctions.hpp" #include "glextensions_list.hpp" +#include "../base/stl_add.hpp" #include "../base/assert.hpp" VertexArrayBuffer::VertexArrayBuffer(uint32_t indexBufferSize, uint32_t dataBufferSize) : m_VAO(0) , m_dataBufferSize(dataBufferSize) - , m_program(NULL) + , m_program() { m_indexBuffer.Reset(new IndexBuffer(indexBufferSize)); } @@ -15,11 +16,7 @@ VertexArrayBuffer::VertexArrayBuffer(uint32_t indexBufferSize, uint32_t dataBuff VertexArrayBuffer::~VertexArrayBuffer() { m_indexBuffer.Destroy(); - buffers_map_t::iterator it = m_buffers.begin(); - for (; it != m_buffers.end(); ++it) - it->second.Destroy(); - - m_buffers.clear(); + GetRangeDeletor(m_buffers, MasterPointerDeleter()); if (m_VAO != 0) { @@ -48,7 +45,7 @@ void VertexArrayBuffer::Render() } } -void VertexArrayBuffer::Build(ReferencePoiner<GpuProgram> program) +void VertexArrayBuffer::Build(RefPointer<GpuProgram> program) { ASSERT(m_VAO == 0 && m_program.IsNull(), ("No-no-no! You can't rebuild VertexArrayBuffer")); m_program = program; @@ -64,17 +61,17 @@ void VertexArrayBuffer::Build(ReferencePoiner<GpuProgram> program) BindBuffers(); } -ReferencePoiner<GLBuffer> VertexArrayBuffer::GetBuffer(const BindingInfo & bindingInfo) +RefPointer<GLBuffer> VertexArrayBuffer::GetBuffer(const BindingInfo & bindingInfo) { buffers_map_t::iterator it = m_buffers.find(bindingInfo); if (it == m_buffers.end()) { - OwnedPointer<DataBuffer> buffer(new DataBuffer(bindingInfo.GetElementSize(), m_dataBufferSize)); - m_buffers.insert(make_pair(bindingInfo, buffer)); - return buffer.GetWeakPointer<GLBuffer>(); + MasterPointer<DataBuffer> & buffer = m_buffers[bindingInfo]; + buffer.Reset(new DataBuffer(bindingInfo.GetElementSize(), m_dataBufferSize)); + return buffer.GetRefPointer(); } - return it->second.GetWeakPointer<GLBuffer>(); + return it->second.GetRefPointer(); } uint16_t VertexArrayBuffer::GetAvailableIndexCount() const @@ -130,7 +127,7 @@ void VertexArrayBuffer::BindBuffers() for (; it != m_buffers.end(); ++it) { const BindingInfo & binding = it->first; - ReferencePoiner<DataBuffer> buffer = it->second.GetWeakPointer(); + RefPointer<DataBuffer> buffer = it->second.GetRefPointer(); buffer->Bind(); for (uint16_t i = 0; i < binding.GetCount(); ++i) diff --git a/drape/vertex_array_buffer.hpp b/drape/vertex_array_buffer.hpp index 6acc46cc0b..1a7cad8f38 100644 --- a/drape/vertex_array_buffer.hpp +++ b/drape/vertex_array_buffer.hpp @@ -19,10 +19,10 @@ public: /// OES_vertex_array_object create OpenGL resource that belong only one GL context (which was created by) /// by this reason Build/Bind and Render must be called only on Frontendrendere thread void Render(); - void Build(ReferencePoiner<GpuProgram> program); + void Build(RefPointer<GpuProgram> program); ///@} - ReferencePoiner<GLBuffer> GetBuffer(const BindingInfo & bindingInfo); + RefPointer<GLBuffer> GetBuffer(const BindingInfo & bindingInfo); uint16_t GetAvailableVertexCount() const; uint16_t GetAvailableIndexCount() const; @@ -35,11 +35,11 @@ private: private: int m_VAO; - typedef map<BindingInfo, OwnedPointer<DataBuffer> > buffers_map_t; + typedef map<BindingInfo, MasterPointer<DataBuffer> > buffers_map_t; buffers_map_t m_buffers; - OwnedPointer<IndexBuffer> m_indexBuffer; + MasterPointer<IndexBuffer> m_indexBuffer; uint32_t m_dataBufferSize; - ReferencePoiner<GpuProgram> m_program; + RefPointer<GpuProgram> m_program; }; diff --git a/drape_head/glwidget.cpp b/drape_head/glwidget.cpp index 7f2476750b..73dbe4f9b5 100644 --- a/drape_head/glwidget.cpp +++ b/drape_head/glwidget.cpp @@ -3,24 +3,38 @@ #include "../drape/shader_def.hpp" +#include "../base/stl_add.hpp" + +namespace +{ + struct Deleter + { + void operator()(pair<const GLState, vector<MasterPointer<VertexArrayBuffer> > > & value) + { + GetRangeDeletor(value.second, MasterPointerDeleter())(); + } + }; +} + GLWidget::GLWidget() { - m_batcher = new Batcher(ReferencePoiner<IBatchFlush>(this)); + m_batcher = new Batcher(MakeStackRefPointer((IBatchFlush *)this)); m_programManager = new GpuProgramManager(); } -void GLWidget::FlushFullBucket(const GLState & state, OwnedPointer<VertexArrayBuffer> bucket) +GLWidget::~GLWidget() { - ReferencePoiner<GpuProgram> program = m_programManager->GetProgram(state.GetProgramIndex()); - bucket->Build(program); - m_frames[state].push_back(bucket); + GetRangeDeletor(m_frames, Deleter())(); + delete m_batcher; + delete m_programManager; } -void GLWidget::UseIncompleteBucket(const GLState &state, ReferencePoiner<VertexArrayBuffer> bucket) +void GLWidget::FlushFullBucket(const GLState & state, TransferPointer<VertexArrayBuffer> bucket) { - ReferencePoiner<GpuProgram> program = m_programManager->GetProgram(state.GetProgramIndex()); - bucket->Build(program); - renderBucket(state, bucket); + RefPointer<GpuProgram> program = m_programManager->GetProgram(state.GetProgramIndex()); + MasterPointer<VertexArrayBuffer> masterBucket(bucket); + masterBucket->Build(program); + m_frames[state].push_back(masterBucket); } void GLWidget::initializeGL() @@ -62,6 +76,7 @@ void GLWidget::initializeGL() gen.SetViewport(-1.0f, -1.0f, 2.0f, 2.0f); gen.SetUniforms(uniforms); gen.Generate(30, *m_batcher); + m_batcher->Flush(); } void GLWidget::paintGL() @@ -79,15 +94,15 @@ void GLWidget::paintGL() { for (size_t i = 0; i < it->second.size(); ++i) { - renderBucket(it->first, it->second[i].GetWeakPointer()); + renderBucket(it->first, it->second[i].GetRefPointer()); } } } } -void GLWidget::renderBucket(const GLState & state, ReferencePoiner<VertexArrayBuffer> bucket) +void GLWidget::renderBucket(const GLState & state, RefPointer<VertexArrayBuffer> bucket) { - ReferencePoiner<GpuProgram> program = m_programManager->GetProgram(state.GetProgramIndex()); + RefPointer<GpuProgram> program = m_programManager->GetProgram(state.GetProgramIndex()); ApplyState(state, program); bucket->Render(); } diff --git a/drape_head/glwidget.hpp b/drape_head/glwidget.hpp index b19057b9a6..e5d70cfa9a 100644 --- a/drape_head/glwidget.hpp +++ b/drape_head/glwidget.hpp @@ -9,9 +9,9 @@ class GLWidget : public QGLWidget, public IBatchFlush { public: GLWidget(); + ~GLWidget(); - virtual void FlushFullBucket(const GLState & state, OwnedPointer<VertexArrayBuffer> bucket); - virtual void UseIncompleteBucket(const GLState & state, ReferencePoiner<VertexArrayBuffer> bucket); + virtual void FlushFullBucket(const GLState & state, TransferPointer<VertexArrayBuffer> bucket); protected: void initializeGL(); @@ -19,10 +19,10 @@ protected: void resizeGL(int w, int h); private: - void renderBucket(const GLState & state, ReferencePoiner<VertexArrayBuffer> bucket); + void renderBucket(const GLState & state, RefPointer<VertexArrayBuffer> bucket); private: - typedef map<GLState, vector<OwnedPointer<VertexArrayBuffer> > > frames_t; + typedef map<GLState, vector<MasterPointer<VertexArrayBuffer> > > frames_t; frames_t m_frames; private: |