CustomLandmarkRenderable.h

// Copyright eeGeo Ltd (2012-2014), All Rights Reserved

#pragma once

#include "PackedRenderable.h"
#include "LayerIds.h"
#include "Rendering.h"
#include "CullingVolume.h"
#include "VectorMathDecl.h"
#include "AsyncTexturing.h"
#include "IAsyncTexture.h"
#include <string>
#include <map>

namespace Eegeo
{
    namespace Rendering
    {
        namespace Renderables
        {
            class CustomLandmarkRenderable : public PackedRenderable
            {
            public:
                CustomLandmarkRenderable(
                                 LayerIds::Values layerId,
                                 Materials::IMaterial* material,
                                 Rendering::Mesh* pMesh,
                                 Culling::CullingVolumeTree* pCullingVolumeTree,
                                 const VertexLayouts::VertexBinding& vertexBinding,
                                 Eegeo::dv3 ecefPosition,
                                 Eegeo::v4 positionBoundsMin,
                                 Eegeo::v4 positionBoundsMax,
                                 Eegeo::v2 uvBoundsMin,
                                 Eegeo::v2 uvBoundsMax,
                                 const std::string& landmarkTextureName,
                                 const std::string& renderableName)
                : PackedRenderable(
                                   layerId,
                                   material,
                                   pMesh,
                                   pCullingVolumeTree,
                                   vertexBinding,
                                   ecefPosition,
                                   positionBoundsMin,
                                   positionBoundsMax,
                                   uvBoundsMin,
                                   uvBoundsMax)
                , m_landmarkTextureName(landmarkTextureName)
                , m_renderableName(renderableName)
                , m_alpha(1.f)
                , m_originalEcefPosition(ecefPosition)
                {
                }
                
                virtual ~CustomLandmarkRenderable()
                {
                    ClearTextures();
                }

                virtual void ClearTextures()
                {
                    for (std::map<std::string, Rendering::AsyncTexturing::IAsyncTexture*>::iterator it = m_textureIdsByState.begin();
                         it != m_textureIdsByState.end();
                         ++it)
                    {
                        it->second->Release();
                    }
                    m_textureIdsByState.clear();
                }
                
                const std::string& GetLandmarkTextureName() const
                {
                    return m_landmarkTextureName;
                }
                
                const std::string& GetRenderableName() const
                {
                    return m_renderableName;
                }

                void RegisterTextureForState(const std::string& stateName, Rendering::AsyncTexturing::IAsyncTexture& asyncTexture)
                {
                    Eegeo_ASSERT(m_textureIdsByState.find(stateName) == m_textureIdsByState.end(), "state already registered");
                    m_textureIdsByState[stateName] = &asyncTexture;
                }
                
                TTextureId GetTextureForState(const std::string& stateName) const
                {
                    Rendering::AsyncTexturing::IAsyncTexture* pAsyncTexture = m_textureIdsByState.at(stateName);
                    return pAsyncTexture->GetTextureInfo().textureId;
                }
                
                bool ShouldRender() const
                {
                    const float MinimumAlphaForRendering = 1.0f / 256.0f;
                    return m_alpha > MinimumAlphaForRendering;
                }
                
                const dv3& GetOriginalEcefPosition() const { return m_originalEcefPosition; }
                
                virtual void SetAlpha(float alpha) { m_alpha = alpha; }
                float GetAlpha() const { return m_alpha; }
                
            protected:
                const std::string m_landmarkTextureName;
                const std::string m_renderableName;
                std::map<std::string, Rendering::AsyncTexturing::IAsyncTexture*> m_textureIdsByState;
                float m_alpha;
                
                const dv3 m_originalEcefPosition;

                
            };
        }
    }
}