TiledGraphNode.h

#pragma once

#include "Graphs.h"
#include "VectorMath.h"
#include "MortonKey.h"

#include <functional>
#include <vector>
#include <sstream>

namespace Eegeo
{
    namespace Graphs
    {
        struct TiledGraphNodeId
        {
            TiledGraphNodeId()
            : CellKey(Eegeo::Streaming::MortonKey(0))
            , LocalNodeId(-1)
            {}

            TiledGraphNodeId(
                const Eegeo::Streaming::MortonKey& cellKey,
                int localNodeId
            )
                : CellKey(cellKey)
                , LocalNodeId(localNodeId)
            {}

            TiledGraphNodeId(const TiledGraphNodeId& other)
                : CellKey(other.CellKey)
                , LocalNodeId(other.LocalNodeId)
            {}


            Eegeo::Streaming::MortonKey CellKey;
            int LocalNodeId;
        };

        inline bool operator == (const TiledGraphNodeId& lhs, const TiledGraphNodeId& rhs)
        {
            return (lhs.LocalNodeId == rhs.LocalNodeId) &&
                (lhs.CellKey == rhs.CellKey);
        }

        inline std::string TiledGraphNodeIdToString(const TiledGraphNodeId& nodeId)
        {
            std::stringstream ss;
            ss << nodeId.CellKey.ToString() << ":" << nodeId.LocalNodeId;
            return ss.str();
        }

        inline TiledGraphNodeId MakeExternalTiledGraphNodeId()
        {
            return TiledGraphNodeId(Streaming::MortonKey(0), -1);
        }

        struct TiledGraphNodeIdHash
        {
            std::size_t operator()(const TiledGraphNodeId& nodeId) const
            {
                std::size_t h1 = Eegeo::Streaming::MortonKeyHash{}(nodeId.CellKey);
                std::size_t h2 = std::hash<int>{}(nodeId.LocalNodeId);
                return h1 ^ (h2 << 1);
            }
        };

        struct TiledGraphNode
        {
            TiledGraphNode()
                : LocalPoint(v3::Zero())
                , IncidentEdgesOffset(0)
                , IncidentEdgesCount(0)
            {}

            TiledGraphNode(
                const v3& localPoint,
                int incidentEdgesOffset,
                int incidentEdgesCount
            )
                : LocalPoint(localPoint)
                , IncidentEdgesOffset(incidentEdgesOffset)
                , IncidentEdgesCount(incidentEdgesCount)
            {}

            v3 LocalPoint;
            int IncidentEdgesOffset;
            int IncidentEdgesCount;
        };
        
        inline bool operator == (const TiledGraphNode& lhs, const TiledGraphNode& rhs)
        {
            return (lhs.LocalPoint == rhs.LocalPoint) &&
            (lhs.IncidentEdgesOffset == rhs.IncidentEdgesOffset) &&
            (lhs.IncidentEdgesCount == rhs.IncidentEdgesCount);
        }
    }
}