RasterTerrainBuilder.h

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

#pragma once

#include "Types.h"
#include "IResourceBuilder.h"
#include "Rendering.h"
#include "Terrain.h"
#include "Streaming.h"
#include "IJpegLoader.h"
#include "AsyncTexturing.h"
#include "ISceneElementInGraphObserver.h"
#include "UniqueTextureRenderable.h"

namespace Eegeo
{
    namespace Resources
    {
        namespace Terrain
        {
            namespace Raster
            {
                struct TerrainBuilderOutput
                {
                    TerrainBuilderOutput(Rendering::Renderables::UniqueTextureRenderable* renderable, RasterTerrainHeightLookup* rasterTerrainHeightLookup, const std::string& debugName)
                    :renderable(renderable)
                    ,rasterTerrainHeightLookup(rasterTerrainHeightLookup)
                    ,debugName(debugName)
                    {}

                    Rendering::Renderables::UniqueTextureRenderable* renderable;

                    RasterTerrainHeightLookup* rasterTerrainHeightLookup;

                    const std::string debugName;
                };

                
                class RasterTerrainBuilder : protected Eegeo::NonCopyable, public IResourceBuilder
                {
                    Eegeo::Rendering::MeshFactories::MeshFactory& m_diffuseMeshFactory;
                    Rendering::IMeshUploadService* m_pMeshUploadService;
                    Rendering::IMaterialProvider& m_materialProvider;
                    Heights::TerrainHeightRepository& m_terrainHeightRepository;
                    Rendering::VertexLayouts::VertexBindingPool& m_vertexBindingPool;
                    Rendering::AsyncTexturing::IAsyncBufferTextureRequestor& m_asyncTextureRequestor;
                    Rendering::Scene::SceneElementRepository<Rendering::Renderables::WorldMeshRenderable>& m_sceneElementRepository;
                    Rendering::Scene::ISceneElementInGraphObserver<Rendering::Renderables::WorldMeshRenderable>* m_pWorldSceneGraphObserver;
                    Rendering::Renderables::IUniqueTextureRenderableFactory& m_uniqueTextureRenderableFactory;
                    
                public:
                    RasterTerrainBuilder(Eegeo::Rendering::MeshFactories::MeshFactory& diffuseMeshFactory,
                                         Rendering::IMeshUploadService* pMeshUploadService,
                                         Rendering::IMaterialProvider& materialProvider,
                                         Rendering::VertexLayouts::VertexBindingPool& vertexBindingPool,
                                         Heights::TerrainHeightRepository& terrainHeightRepository,
                                         Rendering::Scene::SceneElementRepository<Rendering::Renderables::WorldMeshRenderable>& sceneElementRepository,
                                         Rendering::AsyncTexturing::IAsyncBufferTextureRequestor& asyncTextureRequestor,
                                         Rendering::Scene::ISceneElementInGraphObserver<Rendering::Renderables::WorldMeshRenderable>* pWorldSceneGraphObserver,
                                         Rendering::Renderables::IUniqueTextureRenderableFactory& uniqueTextureRenderableFactory)
                    : m_diffuseMeshFactory(diffuseMeshFactory)
                    , m_pMeshUploadService(pMeshUploadService)
                    , m_materialProvider(materialProvider)
                    , m_terrainHeightRepository(terrainHeightRepository)
                    , m_vertexBindingPool(vertexBindingPool)
                    , m_asyncTextureRequestor(asyncTextureRequestor)
                    , m_sceneElementRepository(sceneElementRepository)
                    , m_pWorldSceneGraphObserver(pWorldSceneGraphObserver)
                    , m_uniqueTextureRenderableFactory(uniqueTextureRenderableFactory)
                    { }
                    
                    virtual bool Flush(const Streaming::MortonKey& key, void* input, TBuiltResources& result);
                    virtual void DestroyBuiltResource(const Streaming::MortonKey& key, void* input);

                    virtual void* BuildResource(const Streaming::MortonKey& key, const Byte* data, size_t length);
                    virtual bool AcceptsErroredRequests()
                    {
                        return true;
                    }
                };
            }
        }
    }
}