ChunkedBuildingBuilder.h

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

#pragma once

#include "Rendering.h"
#include "Types.h"
#include "IResourceBuilder.h"
#include "CityThemes.h"
#include "AsyncTexturing.h"
#include "Streaming.h"
#include "ChunkedFileFormat.h"
#include "Space.h"
#include "Collision.h"
#include "CollisionBvhFactory.h"
#include "LandmarkToRenderableRepository.h"
#include "Buildings.h"
#include "Config.h"

#include <string>
#include <vector>

namespace Eegeo
{
    namespace Resources
    {
        namespace Buildings
        {
            struct ChunkedBuildingBuilderOutput
            {
                ChunkedBuildingBuilderOutput()
                : lowLod(false)
                , pCollisionBvh(NULL)
                {
                }
                
                ~ChunkedBuildingBuilderOutput();
                
                void Clear();
                
                bool lowLod;
                
                std::vector<RenderableCreationData*> shadowRenderableCreationDatas;
                std::vector<RenderableCreationData*> buildingRenderableCreationDatas;
                std::vector<RenderableCreationData*> landmarkRenderableCreationDatas;

                Eegeo::Collision::CollisionBvh* pCollisionBvh;
            };
            
            class ChunkedBuildingBuilder : protected Eegeo::NonCopyable, public IResourceBuilder
            {
            public:
                ChunkedBuildingBuilder(
                                       IO::ChunkedFileFormat::QuantizedMeshSetChunkReader::IQuantizedMeshSetChunkReaderMeshFactory& packedDiffuseReadMeshFactory,
                                       Rendering::IMeshUploadService* pMeshUploadService,
                                       Rendering::Scene::SceneElementRepository<Rendering::Renderables::PackedRenderable>& sceneElementRepository,
                                       Rendering::Scene::SceneElementRepository<Rendering::Renderables::PackedRenderable>& shadowSceneElementRepository,
                                       Eegeo::Collision::CollisionMeshResourceRepository& collisionMeshResourceRepository,
                                       bool generateCollision,
                                       Rendering::IMaterialProvider& materialProvider,
                                       Rendering::VertexLayouts::VertexBindingPool& vertexBindingPool,
                                       Resources::CityThemes::ICityThemesService& cityThemeService,
                                       ILandmarkTextureLoader& landmarkTextureLoader,
                                       ILandmarkRenderableFactory& landmarkRenderableFactory,
                                       Rendering::Scene::ISceneElementInGraphObserver<Rendering::Renderables::PackedRenderable>& landmarkSceneGraphObserver,
                                       const Config::ResourceBuilderConfigSection& resourceBuilderConfig,
                                       Rendering::Scene::ISceneElementInGraphObserver<Rendering::Renderables::PackedRenderable>* pBuildingSceneGraphObserver,
                                       IO::ChunkedFileFormat::QuantizedMeshSetChunkReader::QCMSChunkReader& qcmsChunkReader
                                       )
                : m_packedDiffuseReadMeshFactory(packedDiffuseReadMeshFactory)
                , m_pMeshUploadService(pMeshUploadService)
                , m_sceneElementRepository(sceneElementRepository)
                , m_shadowSceneElementRepository(shadowSceneElementRepository)
                , m_collisionMeshResourceRepository(collisionMeshResourceRepository)
                , m_bGenerateCollision(generateCollision)
                , m_materialProvider(materialProvider)
                , m_vertexBindingPool(vertexBindingPool)
                , m_cityThemeService(cityThemeService)
                , m_landmarkTextureLoader(landmarkTextureLoader)
                , m_landmarkRenderableFactory(landmarkRenderableFactory)
                , m_landmarkSceneGraphObserver(landmarkSceneGraphObserver)
                , m_resourceBuilderConfig(resourceBuilderConfig)
                , m_pBuildingSceneGraphObserver(pBuildingSceneGraphObserver)
                , m_qcmsChunkReader(qcmsChunkReader)
                , m_collisionBvhFactory(Eegeo::Collision::CollisionGroup::Buildings)
                {
                }
                
                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 false;
                }
                
            private:
                
                bool IsAlpha(const std::string &textureName) const;
                
                void BuildFromQuantizedMeshSet(const Space::CubeMap::CubeMapCellInfo& cellInfo, IO::ChunkedFileFormat::ChunkStream& chunkStream, Resources::BinaryParsing::membuf& membuf, int cellModelChunkChildCount, ChunkedBuildingBuilderOutput& builderOutput);

                IO::ChunkedFileFormat::QuantizedMeshSetChunkReader::IQuantizedMeshSetChunkReaderMeshFactory& m_packedDiffuseReadMeshFactory;
                Rendering::IMeshUploadService* m_pMeshUploadService;
                Rendering::Scene::SceneElementRepository<Rendering::Renderables::PackedRenderable>& m_sceneElementRepository;
                Rendering::Scene::SceneElementRepository<Rendering::Renderables::PackedRenderable>& m_shadowSceneElementRepository;
                Eegeo::Collision::CollisionMeshResourceRepository& m_collisionMeshResourceRepository;
                const bool m_bGenerateCollision;
                Rendering::IMaterialProvider& m_materialProvider;
                Rendering::VertexLayouts::VertexBindingPool& m_vertexBindingPool;
                Resources::CityThemes::ICityThemesService& m_cityThemeService;
                ILandmarkTextureLoader& m_landmarkTextureLoader;
                ILandmarkRenderableFactory& m_landmarkRenderableFactory;
                Rendering::Scene::ISceneElementInGraphObserver<Rendering::Renderables::PackedRenderable>& m_landmarkSceneGraphObserver;
                const Config::ResourceBuilderConfigSection& m_resourceBuilderConfig;
                Rendering::Scene::ISceneElementInGraphObserver<Rendering::Renderables::PackedRenderable>* m_pBuildingSceneGraphObserver;
                IO::ChunkedFileFormat::QuantizedMeshSetChunkReader::QCMSChunkReader& m_qcmsChunkReader;
                Collision::CollisionBvhFactory m_collisionBvhFactory;
            };
        }
    }
}