SceneElement.h

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

#pragma once

#include "ISceneElement.h"
#include "Streaming.h"
#include "Types.h"
#include "ISceneElementRemover.h"
#include "ISceneElementInGraphObserver.h"
#include "MortonKey.h"
#include "PackedRenderable.h" // Has to be included to support the m_pRenderable delete below. Remove as soon as possible
#include "TextRenderable.h" // Has to be included to support the m_pRenderable delete below. Remove as soon as possible

namespace Eegeo
{
    namespace Rendering
    {
        namespace Scene
        {
            template <class TRenderableType>
            class SceneElement : public Resources::IBuiltResource
            {
            public:
                SceneElement(TRenderableType* pRenderable, const Streaming::MortonKey& key, std::string name)
                    : m_pRemover(NULL)
                    , m_pObserver(NULL)
                    , m_pRenderable(pRenderable)
                    , m_isInScene(false)
                    , m_key(key)
                    , m_name(std::move(name))
                {
                }
                
                ~SceneElement()
                {
                    Eegeo_ASSERT(m_pRemover != NULL);
                    m_pRemover->Remove(this);

                    #if !defined(EEGEO_UNITY)
                    Eegeo_ASSERT(m_pRenderable != NULL);
                    #endif

                    Eegeo_DELETE(m_pRenderable); // Calling ~TRenderableType() without knowing its implementation? Smells a bit.
                }

                // Do nothing - legacy, should never be called for this type.
                // IBuiltResource needs this removing.
                void Unload()
                {
                    Eegeo_DELETE(this); //lol.
                }
                
                bool IsInSceneGraph() const
                {
                    return m_isInScene;
                }
                
                void RemovedFromSceneGraph()
                {
                    m_isInScene = false;
                    if(m_pObserver != NULL)
                    {
                        m_pObserver->OnRemovedFromSceneGraph(this);
                    }
                }
                
                void AddedToSceneGraph()
                {
                    m_isInScene = true;
                    if(m_pObserver != NULL)
                    {
                        m_pObserver->OnAddedToSceneGraph(this);
                    }
                }
                
                const Eegeo::Streaming::MortonKey& GetKey() const
                {
                    return m_key;
                }

                const std::string& GetName() const
                {
                    return m_name;
                }
                
                void SetKey(const Eegeo::Streaming::MortonKey& key)
                {
                    m_key = key;
                }
                
                void SetRemover(Rendering::Scene::ISceneElementRemover<TRenderableType>* remover)
                {
                    Eegeo_ASSERT(m_pRemover == NULL);
                    m_pRemover = remover;
                }
                
                void SetObserver(Scene::ISceneElementInGraphObserver<TRenderableType>* pObserver)
                {
                    m_pObserver = pObserver;
                }
                
                TRenderableType& GetResource() const { return *m_pRenderable; }
                
                inline static void Prefetch(const SceneElement<TRenderableType>* pSceneElement)
                {
#ifndef EEGEO_WIN
                    const int prefetchForRead = 0;
                    const u8* p = reinterpret_cast<const u8*>(pSceneElement);
                    __builtin_prefetch(p + 0, prefetchForRead, 0);
#endif
                }
            private:
                Scene::ISceneElementRemover<TRenderableType>* m_pRemover;
                Scene::ISceneElementInGraphObserver<TRenderableType>* m_pObserver;
                TRenderableType* m_pRenderable;
                bool m_isInScene;
                Eegeo::Streaming::MortonKey m_key;
                std::string m_name;

            };
        }
    }
}