ChunkedInteriorsBuilder.h

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

#pragma once

#include "IResourceBuilder.h"
#include "Types.h"
#include "Interiors.h"
#include "InteriorsMaterials.h"
#include "Collision.h"
#include "Rendering.h"
#include "Space.h"
#include "ChunkedFileFormat.h"
#include "CollisionBvhFactory.h"
#include "InteriorMetadataChunkDto.h"
#include "Fonts.h"
#include "Labels.h"
#include "PropResource.h"

#include <string>

namespace Eegeo
{
    namespace Resources
    {
        namespace Interiors
        {
            namespace Builder
            {
                namespace GeometryType
                {
                    enum Values {
                        Default,
                        Highlight,
                        Instance
                    };
                }

                class ChunkedInteriorsBuilder : protected Eegeo::NonCopyable, public IResourceBuilder
                {
                public:

                    ChunkedInteriorsBuilder(InteriorGeometryReader& geometryReader,
                                            InteriorsModelRepository& interiorsModelRepository,
                                            Entities::InteriorsEntitiesRepository& interiorsEntitiesRepository,
                                            Materials::IInteriorRenderablesRepository& interiorRenderablesRepository,
                                            Collision::CollisionMeshResourceRepository& collisionMeshResourceRepository,
                                            Collision::CollisionMeshResourceRepository& highlightCollisionMeshResourceRepository,
                                            InteriorsCellResourceObserver& interiorsCellResourceObserver,
                                            IInteriorLabelBuilder& interiorLabelBuilder,
                                            Labels::ILabelCellResourceObserver& labelCellResourceObserver,
                                            const Fonts::FontInstance& labelFont,
                                            bool buildLabels,
                                            const std::string& defaultInteriorMaterialName,
                                            InteriorRenderableService& interiorRenderableService,
                                            IO::ChunkedFileFormat::QuantizedMeshSetChunkReader::QCMSChunkReader& chunkReader);
                    
                    bool Flush(const Streaming::MortonKey& key, void* input, TBuiltResources& result);
                    void DestroyBuiltResource(const Streaming::MortonKey& key, void* input);
                    
                    void* BuildResource(const Streaming::MortonKey& key, const Byte* data, size_t length);
                    
                    bool AcceptsErroredRequests();

                    InteriorInstanceChunkDto BuildInteriorInstanceChunk(
                        IO::ChunkedFileFormat::ChunkStream& chunkStream,
                        Resources::BinaryParsing::membuf& membuf,
                        const Space::CubeMap::CubeMapCellInfo& cellInfo,
                        const std::string& interiorId,
                        std::vector<InstanceSourceMeshData>& out_meshDatas);

                private:

                    InteriorGeometryReader& m_geometryReader;

                    Collision::CollisionBvhFactory m_collisionBvhFactory;
                    Collision::CollisionBvhFactory m_highlightCollisionBvhFactory;
                    Collision::CollisionBvhFactory m_instancesCollisionBvhFactory;

                    InteriorsModelRepository& m_interiorsModelRepository;
                    Entities::InteriorsEntitiesRepository& m_interiorsEntitiesRepository;
                    Materials::IInteriorRenderablesRepository& m_interiorRenderablesRepository;
                    Collision::CollisionMeshResourceRepository& m_collisionMeshResourceRepository;
                    Collision::CollisionMeshResourceRepository& m_highlightCollisionMeshResourceRepository;
                    InteriorsCellResourceObserver& m_interiorsCellResourceObserver;

                    IInteriorLabelBuilder& m_interiorLabelBuilder;
                    const Fonts::FontInstance& m_labelFont;
                    const bool m_buildLabels;
                    const std::string m_defaultInteriorMaterialName;
                    InteriorRenderableService& m_interiorRenderableService;
                    IO::ChunkedFileFormat::QuantizedMeshSetChunkReader::QCMSChunkReader& m_chunkReader;

                    Eegeo::Collision::CollisionBvhFactory* GetCollisionBvhFactoryForGeometryType(GeometryType::Values geometryType);
                    
                    void CreateFloorResourcesFromQuantizedMeshSet(IO::ChunkedFileFormat::QuantizedMeshSetChunkReader::QCMSChunkReader& qcmsChunkReader,
                                                                  const Space::CubeMap::CubeMapCellInfo& cellInfo,
                                                                  IO::ChunkedFileFormat::ChunkStream& chunkStream,
                                                                  Resources::BinaryParsing::membuf& membuf,
                                                                  const int floorDrawOrder,
                                                                  GeometryType::Values geometryType,
                                                                  const std::string& meshNamePrefix,
                                                                  std::vector<InteriorRenderableCreationData*>& out_renderableCreationDatas,
                                                                  std::vector<Collision::CollisionBvh*>& out_collisionBvhs);

                    void ExtractFloorGeometryData(
                        const IO::ChunkedFileFormat::QuantizedMeshSetChunkReader::ReaderResult &readerResult, 
                        const Eegeo::dv3& cellOrigin,
                        const int floorDrawOrder,
                        GeometryType::Values geometryType,
                        std::vector<InteriorRenderableCreationData*> &out_renderableCreationDatas,
                        std::vector<Collision::CollisionBvh*> &out_collisionBvhs);

                    InteriorsCellResource* CreateInteriorsCellResource(const Streaming::MortonKey& key, const InteriorData& interiorData);
                    
                    std::vector<const InteriorsFloorCell*> CreateInteriorsFloorCells(const Streaming::MortonKey& key,
                                                                                     const InteriorData& interiorData,
                                                                                     const InteriorsModel& interiorModel);
                    
                    InteriorRenderableCreationData* CreateInteriorRenderableCreationData(const Eegeo::dv3& ecefOrigin,
                                                                                         const IO::ChunkedFileFormat::QuantizedMeshSetChunkReader::ReaderMeshResult& readerMeshResult,
                                                                                         const InteriorMaterialData& interiorMaterialData,
                                                                                         Rendering::LayerIds::Values layerId,
                                                                                         int floorIndex);

                    
                };
            }
        }
    }
}