UnityCallbacks.h

#pragma once

#include "Graphics.h"
#include "VectorMathDecl.h"
#include "TransportEventTypes.h"
#include "MortonKey.h"
#include "Unity.h"


namespace Eegeo
{
    namespace Unity
    {
        struct UnpackedMesh;

        // The memory layout of these callbacks classes is important, as they get marshaled over from ApiCallbacks.cs in Unity.
        // If one is changing, both should change.
        class LabelCallbacks
        {
        public:

            void AddLabel(const UnityLabelCreateOptions& createOptions) const
            {
                m_addLabel(m_labelServiceHandle, createOptions);
            }

            void UpdateLabel(const UnityLabelUpdateState& updateState) const
            {
                m_updateLabel(m_labelServiceHandle, updateState);
            }

            void RemoveLabel(const char* labelId) const
            {
                m_removeLabel(m_labelServiceHandle, labelId);
            }

            void AddIconTexturePage(const u32 textureId) const
            {
                m_addIconTexturePage(m_labelServiceHandle, textureId);
            }

        private:

            typedef void(*AddLabelCallback)(const void* labelServiceHandle, const UnityLabelCreateOptions& createOptions);
            typedef void(*UpdateLabelCallback)(const void* labelServiceHandle, const UnityLabelUpdateState& updateState);
            typedef void(*RemoveLabelCallback)(const void* labelServiceHandle, const char* labelId);
            typedef void(*AddIconTexturePageCallback)(const void* labelServiceHandle, const u32 textureId);

            const void* m_labelServiceHandle;
            AddLabelCallback m_addLabel;
            UpdateLabelCallback m_updateLabel;
            RemoveLabelCallback m_removeLabel;
            AddIconTexturePageCallback m_addIconTexturePage;
        };

        class TextureCallbacks
        {
        public:

            void* AllocateTextureBuffer(int size, int width, int height, int format, int hasMipMaps) const
            {
                return m_allocateTextureBuffer(m_textureServiceHandle, size, width, height, format, hasMipMaps);
            }

            GLuint BeginUploadTextureBuffer(const void* buffer) const
            {
                return m_beginUploadTextureBuffer(m_textureServiceHandle, buffer);
            }

            void OnTextureReceived(const void* requestHandle, const char* textureKey, GLuint textureID) const
            {
                m_onTextureReceived(requestHandle, textureKey, textureID);
            }

            void ReleaseTexture(GLuint id) const
            {
                m_releaseTexture(m_textureServiceHandle, id);
            }

            GLuint CreateCubemapFromFaces(const GLuint* faceIDs) const
            {
                return m_createCubemapFromFaces(m_textureServiceHandle, faceIDs);
            }

        private:

            typedef void* (*AllocateTextureBufferCallback)(const void* textureServiceHandle, int size, int width, int height, int format, int hasMipMaps);
            typedef GLuint(*BeginUploadTextureBufferCallback)(const void* textureServiceHandle, const void* buffer);
            typedef void(*OnTextureReceivedCallback)(const void* requestHandle, const char* textureKey, GLuint textureID);
            typedef void(*ReleaseTextureCallback)(const void* textureServiceHandle, GLuint id);
            typedef GLuint(*CreateCubemapFromFacesCallback)(const void* textureServiceHandle, const GLuint* faceIDs);

            const void* m_textureServiceHandle;
            AllocateTextureBufferCallback m_allocateTextureBuffer;
            BeginUploadTextureBufferCallback m_beginUploadTextureBuffer;
            OnTextureReceivedCallback m_onTextureReceived;
            ReleaseTextureCallback m_releaseTexture;
            CreateCubemapFromFacesCallback m_createCubemapFromFaces;
        };

        class MaterialCallbacks
        {
        public:
            void OnMaterialMadeDirty(const char* textureKey, const char* materialName) const
            {
                m_onMaterialMadeDirty(m_materialRepositoryHandle, textureKey, materialName);
            }


        private:
            typedef void(*OnMaterialMadeDirtyCallback)(const void* materialRepositoryHandle, const char* textureKey, const char* materialName);

            const void* m_materialRepositoryHandle;
            OnMaterialMadeDirtyCallback m_onMaterialMadeDirty;
        };


        class ThreadServiceCallbacks
        {
        public:

            typedef void* (*StartThreadCallback)(void* startData);

            int CreateThread(StartThreadCallback callback, void* startData) const
            {
                return m_createThread(m_threadServiceHandle, callback, startData);
            }

            void JoinThread(int threadHandle) const
            {
                m_joinThread(m_threadServiceHandle, threadHandle);
            }

        private:

            typedef int(*CreateThreadCallback)(const void* threadServiceHandle, StartThreadCallback callback, void* startData);
            typedef void(*JoinThreadCallback)(const void* threadServiceHandle, int threadHandle);

            const void* m_threadServiceHandle;
            CreateThreadCallback m_createThread;
            JoinThreadCallback m_joinThread;
        };

        class SceneCallbacks
        {
            // :HACK: :TEMP: not sure about identifying objects by string ID for this sort of purpose.
            // Think we might be better off using GCHandle IntPtrs

        public:

            void SetScale(const char* objectId, const v3& scale) const
            {
                m_setScale(m_sceneServiceHandle, objectId, scale);
            }

            void SetTranslation(const char* objectId, const v3& translation) const
            {
                m_setTranslation(m_sceneServiceHandle, objectId, translation);
            }

            void SetOrientation(const char* objectId, const Quaternion& rotation) const
            {
                m_setOrientation(m_sceneServiceHandle, objectId, rotation);
            }

            void SetColor(const char* objectId, const v4& color) const
            {
                m_setColor(m_sceneServiceHandle, objectId, color);
            }

        private:

            typedef void(*SetScaleCallback)(const void* sceneServiceHandle, const char* objectId, const v3& scale);
            typedef void(*SetTranslationCallback)(const void* sceneServiceHandle, const char* objectId, const v3& translation);
            typedef void(*SetOrientationCallback)(const void* sceneServiceHandle, const char* objectId, const Quaternion& rotation);
            typedef void(*SetColorCallback)(const void* sceneServiceHandle, const char* objectId, const v4& color);

            const void* m_sceneServiceHandle;
            SetScaleCallback m_setScale;
            SetTranslationCallback m_setTranslation;
            SetOrientationCallback m_setOrientation;
            SetColorCallback m_setColor;
        };

        class MeshCallbacks
        {
        public:

            void SetVisible(const char* objectId, bool visible) const
            {
                m_setVisible(m_sceneServiceHandle, objectId, visible);
            }

            void AddMesh(const char* objectId) const
            {
                m_addMesh(m_sceneServiceHandle, objectId);
            }

            void DeleteMesh(const char* objectId) const
            {
                m_deleteMesh(m_sceneServiceHandle, objectId);
            }

            Unity::UnpackedMesh* AllocateUnpackedMesh(int vertexCount, bool hasUVs, bool hasUV2s, bool hasNormals, bool hasColours, int indexCount, const char* meshName, const char* materialName) const
            {
                return static_cast<Unity::UnpackedMesh*>(m_allocateUnpackedMesh(vertexCount, hasUVs, hasUV2s, hasNormals, hasColours, indexCount, meshName, materialName));
            }

            void UploadUnpackedMesh(const Unity::UnpackedMesh* mesh) const
            {
                m_uploadUnpackedMesh(mesh);
            }

            void RemoveUnpackedMesh(const char* meshId) const
            {
                m_removeUnpackedMesh(meshId);
            }

        private:

            typedef void*(*AllocateUnpackedMeshCallback)(int, bool, bool, bool, bool, int, const void*, const void*);
            typedef void(*UploadUnpackedMeshCallback)(const void*);
            typedef void(*RemoveUnpackedMeshCallback)(const char*);
            typedef void(*AddMeshCallback)(const void* sceneServiceHandle, const char*);
            typedef void(*DeleteMeshCallback)(const void* sceneServiceHandle, const char*);
            typedef void(*VisibilityCallback)(const void* sceneServiceHandle, const char*, bool);

            const void* m_sceneServiceHandle;
            AllocateUnpackedMeshCallback m_allocateUnpackedMesh;
            UploadUnpackedMeshCallback m_uploadUnpackedMesh;
            RemoveUnpackedMeshCallback m_removeUnpackedMesh;
            AddMeshCallback m_addMesh;
            DeleteMeshCallback m_deleteMesh;
            VisibilityCallback m_setVisible;
        };

        class UnityInteriorFloorRenderable;
        class UnityInteriorHighlightRenderable;
        class UnityInstancedInteriorFloorRenderable;

        class IndoorMapCallbacks
        {
        public:

            void OnIndoorMapEntered() const
            {
                m_onIndoorMapEnteredCallback(m_indoorMapsApiHandle);
            }

            void OnIndoorMapExited() const
            {
                m_onIndoorMapExitedCallback(m_indoorMapsApiHandle);
            }

            void OnIndoorMapFloorChanged() const
            {
                m_onIndoorMapFloorChangedCallback(m_indoorMapsApiHandle);
            }

            void OnIndoorMapEntityClicked(const int entityIdsCount, const char** entityIds) const
            {
                EntityClickedInterop interop;
                interop.stringCount = entityIdsCount;
                interop.stringValues = entityIds;

                m_onIndoorMapEntityClickedCallback(m_indoorMapsApiHandle, &interop);
            }

            void AddIndoorMapRenderable(const char* name, const char* interior, const UnityInteriorFloorRenderable& renderable) const
            {
                m_addRenderable(m_indoorMapSceneHandle, name, interior, &renderable);
            }

            void AddIndoorMapHighlightRenderable(const char* name, const char* interior, const UnityInteriorHighlightRenderable& renderable) const
            {
                m_addHighlightRenderable(m_indoorMapSceneHandle, name, interior, &renderable);
            }

            void AddInstancedIndoorMapRenderable(
                const char* meshId, 
                const char* renderableId, 
                const char* interior, 
                const Eegeo::dv3& originEcef, 
                const int transformCount, 
                const v3* positionOffsets, 
                const Quaternion* orientations, 
                const UnityInstancedInteriorFloorRenderable& renderable, 
                int indexOffset, 
                bool ownsMesh) const
            {
                m_addInstancedRenderable(m_indoorMapSceneHandle, meshId, renderableId, interior, &originEcef, transformCount, positionOffsets, orientations, &renderable, indexOffset, ownsMesh);
            }

            void OnRenderableStateUpdated(const char* renderableId) const
            {
                m_onRenderableStateUpdated(m_indoorMapSceneHandle, renderableId);
            }

            void OnHighlightRenderableStateUpdated(const char* renderableId) const
            {
                m_onRenderableStateUpdatedForHighlightRenderable(m_indoorMapSceneHandle, renderableId);
            }

            void OnInstancedRenderableStateUpdated(const char* renderableId) const
            {
                m_onInstancedRenderableStateUpdated(m_indoorMapSceneHandle, renderableId);
            }

            void SetMaterial(const char* objectID, const void* materialHandle) const
            {
                m_setMaterial(m_indoorMapSceneHandle, objectID, materialHandle);
            }

            void SetMaterialForInstancedRenderable(const char* objectID, const void* materialHandle) const
            {
                m_setMaterialForInstancedRenderable(m_indoorMapSceneHandle, objectID, materialHandle);
            }

            void* CreateMaterial(
                const char* indoorMapName,
                const char* materialName,
                int stringCount, const char** stringKeys, const char** stringValues,
                int colorCount, const char** colorNames, const Eegeo::v4* colorValues,
                int scalarCount, const char** scalarNames, const float* scalarValues,
                int booleanCount, const char** booleanNames, const int* booleanValues) const
            {
                MaterialDescriptorInterop interop;
                interop.indoorMapName = indoorMapName;
                interop.materialName = materialName;
                interop.stringCount = stringCount;
                interop.stringKeys = stringKeys;
                interop.stringValues = stringValues;
                interop.colorCount = colorCount;
                interop.colorNames = colorNames;
                interop.colorValues = colorValues;
                interop.scalarCount = scalarCount;
                interop.scalarNames = scalarNames;
                interop.scalarValues = scalarValues;
                interop.booleanCount = booleanCount;
                interop.booleanNames = booleanNames;
                interop.booleanValues = booleanValues;
                interop.materialServiceHandle = m_indoorMapMaterialServiceHandle;

                return m_createMaterial(&interop);
            }

            void DeleteMaterial(const void* materialHandle) const
            {
                m_deleteMaterial(m_indoorMapMaterialServiceHandle, materialHandle);
            }

        private:

            struct MaterialDescriptorInterop
            {
                const char* indoorMapName;
                const char* materialName;
                int stringCount;
                const char** stringKeys;
                const char** stringValues;
                int colorCount;
                const char** colorNames;
                const Eegeo::v4* colorValues;
                int scalarCount;
                const char** scalarNames;
                const float* scalarValues;
                int booleanCount;
                const char** booleanNames;
                const int* booleanValues;
                const void* materialServiceHandle;
            };

            struct EntityClickedInterop
            {
                int stringCount;
                const char** stringValues;
            };

            typedef void(*OnIndoorMapEnteredCallback)(const void* unityIndoorMapApiHandle);
            typedef void(*OnIndoorMapExitedCallback)(const void* unityIndoorMapApiHandle);
            typedef void(*OnIndoorMapFloorChangedCallback)(const void* unityIndoorMapApiHandle);
            typedef void(*OnIndoorMapEntityClickedCallback)(const void* unityIndoorMapApiHandle, const EntityClickedInterop* entityClickedInterop);
            typedef void(*AddIndoorMapRenderableCallback)(const void* indoorMapSceneHandle, const char* name, const char* interior, const void* renderable);
            typedef void(*AddInstancedIndoorMapRenderableCallback)(const void* indoorMapSceneHandle, const char* meshId, const char* renderableId, const char* interior, const Eegeo::dv3* originEcef, const int transformCount, const v3* positionOffsets, const Quaternion* orientations, const void* renderable, int indexOffset, bool ownsMesh);
            typedef void(*OnRenderStateUpdatedCallback)(const void* indoorMapSceneHandle, const char* objectId);
            typedef void* (*CreateMaterialCallback)(const MaterialDescriptorInterop* materialDescriptorInterop);

            typedef void(*SetMaterialCallback)(const void* indoorMapSceneHandle, const char* objectID, const void* materialHandle);
            typedef void(*DeleteMaterialCallback)(const void* indoorMapMaterialServiceHandle, const void* materialHandle);

            const void* m_indoorMapsApiHandle;
            const void* m_indoorMapMaterialServiceHandle;
            const void* m_indoorMapSceneHandle;
            AddIndoorMapRenderableCallback m_addRenderable;
            AddIndoorMapRenderableCallback m_addHighlightRenderable;
            AddInstancedIndoorMapRenderableCallback m_addInstancedRenderable;
            OnRenderStateUpdatedCallback m_onRenderableStateUpdated;
            OnRenderStateUpdatedCallback m_onRenderableStateUpdatedForHighlightRenderable;
            OnRenderStateUpdatedCallback m_onInstancedRenderableStateUpdated;
            SetMaterialCallback m_setMaterial;
            SetMaterialCallback m_setMaterialForInstancedRenderable;
            OnIndoorMapEnteredCallback m_onIndoorMapEnteredCallback;
            OnIndoorMapExitedCallback m_onIndoorMapExitedCallback;
            OnIndoorMapFloorChangedCallback m_onIndoorMapFloorChangedCallback;
            OnIndoorMapEntityClickedCallback m_onIndoorMapEntityClickedCallback;
            CreateMaterialCallback m_createMaterial;
            DeleteMaterialCallback m_deleteMaterial;
        };

        class PositionerCallbacks
        {
        public:

            void PositionerTransformedPointChanged(int positionerId)
            {
                m_positionerTransformedPointChangedCallback(m_positionersApiInternalHandle, positionerId);
            }

            void PositionersProjectionChanged()
            {
                m_positionersProjectionChangedCallback(m_positionersApiInternalHandle);
            }

        private:
            // these correspond to struct PositionerCallbacks in ApiCallbacks.cs
            typedef void(*PositionerTransformedPointChangedCallback)(const void* positionersApiInternalHandle, int positionerId);
            typedef void(*PositionersProjectionChangedCallback)(const void* positionersApiInternalHandle);

            const void* m_positionersApiInternalHandle;
            PositionerTransformedPointChangedCallback m_positionerTransformedPointChangedCallback;
            PositionersProjectionChangedCallback m_positionersProjectionChangedCallback;
        };

        class CameraCallbacks
        {
        public:

            void OnCameraEvent(int eventType)
            {
                m_cameraEventCallback(m_cameraApiHandle, eventType);
            }

        private:

            typedef void(*CameraEventCallback)(const void* apiHandle, int eventType);

            const void* m_cameraApiHandle;
            CameraEventCallback m_cameraEventCallback;
        };

        class BuildingHighlightCallbacks
        {
        public:

            void OnBuildingHighlightChanged(int buildingId)
            {
                m_buildingHighlightChanged(m_buildingsApiInternalHandle, buildingId);
            }

            void OnBuildingHighlightColorChanged(int buildingId, const v4& color) const
            {
                m_buildingHighlightColorChanged(m_buildingsApiInternalHandle, buildingId, color);
            }

            void OnBuildingHighlightClipPlanesChanged(int buildingId, const UnityBuildingHighlightClipPlanePairInterop* clipPlanePairs, int size) const
            {
                m_buildingHighlightClipPlanesChanged(m_buildingsApiInternalHandle, buildingId, clipPlanePairs, size);
            }

        private:
            typedef void(*BuildingHighlightChangedCallback)(const void* buildingsApiInternalHandle, int buildingId);
            // Other places in this file use v4 instead of ColorInterop, even though Unity expects the latter.
            // It works fine as the memory layout is currently the same, but we might want to move ColorInterop to a header this file can include at some point.
            typedef void(*BuildingHighlightColorChangedCallback)(const void* buildingsApiInternalHandle, int buildingId, const v4& color);
            typedef void(*BuildingHighlightClipPlanesChangedCallback)(const void* buildingsApiInternalHandle, int buildingId, const UnityBuildingHighlightClipPlanePairInterop* clipPlanePairs, int size);

            const void* m_buildingsApiInternalHandle;
            BuildingHighlightChangedCallback m_buildingHighlightChanged;
            BuildingHighlightColorChangedCallback m_buildingHighlightColorChanged;
            BuildingHighlightClipPlanesChangedCallback m_buildingHighlightClipPlanesChanged;
        };

        class PrecacheCallbacks
        {
        public:

            void OnPrecacheOperationCompleted(int operationId, bool succeeded)
            {
                m_precacheOperationCompletedHandler(m_precacheApiHandle, operationId, succeeded);
            }

        private:

            typedef void(*PrecacheOperationCompletedEventHandler)(const void* precacheApiHandle, int operationId, bool succeeded);

            const void* m_precacheApiHandle;
            PrecacheOperationCompletedEventHandler m_precacheOperationCompletedHandler;
        };

        namespace Interop
        {
            // Workaround to avoid EegeoApi types in this platform header
            // Todo - needs restructure (move Unity entry point out to eegeo-api-host)
            struct MortonKeyInterop
            {
                s64 Value;
            };
        }

        class TransportCallbacks
        {
        public:
            void OnTransportPositionerPointOnGraphChanged(int transportPositionerId)
            {
                m_transportPositionerPointOnGraphChangedHandler(m_transportApiHandle, transportPositionerId);
            }

            void OnTransportGraphChanged(const Eegeo::Transport::TransportGraphChangedMessage& transportGraphChangedMessage)
            {
                Interop::MortonKeyInterop cellKeyInterop =  {transportGraphChangedMessage.CellKey.RawValue()};
                m_transportPositionerGraphChangedHandler(m_transportApiHandle, transportGraphChangedMessage.TransportNetworkType, cellKeyInterop, transportGraphChangedMessage.ChangeReason);
            }

        private:
            typedef void(*TransportPositionerPointOnGraphChangedHandler)(const void* transportApiHandle, int transportPositionerId);
            typedef void(*TransportPositionerGraphChangedHandler)(
                const void* transportApiHandle,
                Eegeo::Transport::TransportNetwork::Type transportNetworkType,
                Interop::MortonKeyInterop cellKey,
                Eegeo::Transport::TransportGraphChangeReason::Type changeReason
                );

            const void* m_transportApiHandle;
            TransportPositionerPointOnGraphChangedHandler m_transportPositionerPointOnGraphChangedHandler;
            TransportPositionerGraphChangedHandler m_transportPositionerGraphChangedHandler;

        };

        class IndoorEntityInformationCallbacks
        {
        public:
            void OnIndoorMapEntityInformationChanged(int indoorMapEntityInformationId)
            {
                m_indoorMapEntityInformationChangedHandler(m_indoorMapEntityInformationApiInternalHandle, indoorMapEntityInformationId);
            }

        private:
            typedef void(*IndoorMapEntityInformationChangedHandler)(const void* indoorMapEntityInformationApiInternalHandle, int indoorMapEntityInformationId);

            const void* m_indoorMapEntityInformationApiInternalHandle;
            IndoorMapEntityInformationChangedHandler m_indoorMapEntityInformationChangedHandler;
        };


        class StreamingCallbacks
        {
        public:
            void OnInitialStreamingComplete()
            {
                m_initialStreamingCompleteHandler(m_mapApiInternalHandle);
            }

        private:
            typedef void(*InitialStreamingCompleteHandler)(const void* mapApiInternalHandle);

            const void* m_mapApiInternalHandle;
            InitialStreamingCompleteHandler m_initialStreamingCompleteHandler;
        };

        class StreamingApiCallbacks
        {
        public:
            void OnStreamingStarted()
            {
                m_streamingStartHandler(m_streamingApiInternalHandle);
            }
            void OnStreamingComplete()
            {
                m_streamingCompleteHandler(m_streamingApiInternalHandle);
            }

        private:
            typedef void(*StreamingStartedHandler)(const void* streamingApiInternalHandle);
            typedef void(*StreamingCompleteHandler)(const void* streamingApiInternalHandle);

            const void* m_streamingApiInternalHandle;
            StreamingStartedHandler m_streamingStartHandler;
            StreamingCompleteHandler m_streamingCompleteHandler;
        };

        // This type must be manually maintained to match c# Wrld.ApiCallback
        // An instance is aggregated in AppRunner, constructed from a copy of value passed through from Unity
        // in UNITY_INTERFACE_API Initialize() (PlugInPointsApi.cpp)
        struct UnityCallbacks
        {
            typedef void (*AssertHandlerCallback)(const char*, const char*, int);
            typedef void(*FatalErrorHandlerCallback)(const char*);
#ifdef EMSCRIPTEN
            typedef bool (*UnityResourcesWrapperLoadResourceCallback)(const char*, char**, int32_t*);
            typedef void (*UnityResourcesWrapperFreeResourceBufferCallback)(char*);
            typedef bool (*UnityResourcesWrapperResourceExistsCallback)(const char*);
#endif

            static AssertHandlerCallback assertHandler;
            static FatalErrorHandlerCallback fatalErrorHandler;

            MeshCallbacks meshCallbacks;
            CameraCallbacks cameraCallbacks;
            AssertHandlerCallback assertHandlerCallback;
            FatalErrorHandlerCallback fatalErrorHandlerCallback;
            TextureCallbacks textureCallbacks;
            MaterialCallbacks materialCallbacks;
            ThreadServiceCallbacks threadServiceCallbacks;
            BuildingHighlightCallbacks buildingHighlightCallbacks;
            SceneCallbacks sceneCallbacks;
            IndoorMapCallbacks indoorMapCallbacks;
            PositionerCallbacks positionerCallbacks;
            LabelCallbacks labelCallbacks;
            PrecacheCallbacks precacheCallbacks;
            TransportCallbacks transportCallbacks;
            IndoorEntityInformationCallbacks indoorEntityInformationCallbacks;
            StreamingCallbacks streamingCallbacks;
            StreamingApiCallbacks streamingApiCallbacks;
#ifdef EMSCRIPTEN
            UnityResourcesWrapperLoadResourceCallback loadResourceCallback;
            UnityResourcesWrapperFreeResourceBufferCallback freeResourceBufferCallback;
            UnityResourcesWrapperResourceExistsCallback resourceExistsCallback;
#endif
        };
    }
}