BlockModelRaster.h

#pragma once
#include "BlockModel/Headers/CubeTriangulation.h"
#include "NDEVRSurfacing/Headers/GeometrySurfacing.h"
#include "Design/Headers/Geometry.h"
#include "Base/Headers/Vector.hpp"
#include "Base/Headers/Buffer.hpp"
#include "Base/Headers/BaseFunctions.hpp"
namespace NDEVR
{
    template<uint04 t_size, class t_index_type>
    struct BlockLookupNode
    {
        static_assert(sizeof(t_index_type) < t_size * t_size * t_size, "Invalid size for indexing");
        BlockLookupNode()
        {
            for (uint04 i = 0; i < t_size * t_size * t_size; i++)
                indices[i] = Constant<t_index_type>::Invalid;
        }
        static constexpr t_index_type ConvertToIndex(Vector<3, t_index_type> location)
        {
            if constexpr (t_size == 8)
                return (location[Z] << 6) + (location[Y] << 3) + location[X];
            else
                return t_size * (t_size * location[Z] + location[Y]) + location[X];
        }
        static constexpr t_index_type ConvertToIndex(t_index_type x, t_index_type y, t_index_type z)
        {
            if constexpr (t_size == 8)
                return (z << 6) + (y << 3) + x;
            else
                return t_size * (t_size * z + y) + x;
        }
        static constexpr Vector<3, t_index_type> ConvertFromIndex(t_index_type location)
        {
            Vector<3, t_index_type> vec_location;
            if constexpr (t_size == 8)
            {
                vec_location[Z] = location >> 6;
                vec_location[Y] = (location >> 3) % t_size;
                vec_location[X] = location % t_size;
            }
            else
            {
                vec_location[Z] = location / (t_size * t_size);
                vec_location[Y] = (location / t_size) % t_size;
                vec_location[X] = location % t_size;
            }
            return vec_location;
        }
        inline t_index_type get(Vector<3, t_index_type> location) const
        {
            return indices[ConvertToIndex(location)];
        }
        inline t_index_type set(Vector<3, t_index_type> location, t_index_type index)
        {
            return indices[ConvertToIndex(location)] = index;
        }
        void clear()
        {
            for (uint04 i = 0; i < t_size * t_size * t_size; i++)
                indices[i] = Constant<t_index_type>::Invalid;
        }
        t_index_type indices[t_size * t_size * t_size];
    };

    template<uint04 t_size, class t_index_type>
    struct BlockLookupList : public BlockLookupNode<t_size, t_index_type>
    {
        Buffer<BlockLookupList> children;
    };
    template<uint04 t_size, class t_index_type>
    struct ObjectInfo<BlockLookupNode<t_size, t_index_type>, false, true>
    {
        static const uint01 Dimensions = 0;
        static const bool Vector = true;
        static const bool Buffer = true;
        static const bool Primitive = true;
        static const bool Pointer = false;
        static const bool Unsigned = false;
        static const bool Float = false;
        static const bool Integer = false;
        static const bool Number = false;
        static const bool Enum = false;
        static const bool String = true;
        static const bool Color = false;
        static const bool Boolean = false;
        static constexpr ObjectInfo<uint01, false, false> VectorSub() { return ObjectInfo<uint01, false, false>(); }
    };
    template<class t_point_type, class t_weight_type>
    struct BlockModelCache
    {
        BlockModelCache(uint08 weight_cutoff)
            : weight_cutoff(weight_cutoff)
        {}
        Buffer<Vector<3, uint04>> geo_add_locations;
        Buffer<t_point_type> geo_add_info;
        Buffer<t_weight_type> geo_add_weight;
        Bounds<1, uint04> position_update_bounds = Constant<Bounds<1, uint04>>::Min;
        Bounds<1, uint04> color_update_bounds = Constant<Bounds<1, uint04>>::Min;
        Bounds<1, uint04> normal_update_bounds = Constant<Bounds<1, uint04>>::Min;
        Bounds<1, uint04> weight_update_bounds = Constant<Bounds<1, uint04>>::Min;
        Bounds<1, uint04> primitive_update_bounds = Constant<Bounds<1, uint04>>::Min;
        Bounds<1, uint04> flag_update_bounds = Constant<Bounds<1, uint04>>::Min;
        uint08 weight_cutoff;
        uint08 weight_max_capacity = Constant<uint08>::Min;
    };

    template<class t_point_type, class t_weight_type>
    struct BlockModelGeometryCache : public BlockModelCache<t_point_type, t_weight_type>
    {
        BlockModelGeometryCache(Geometry geo, uint08 weight_cutoff, const void* lock_ptr)
            : BlockModelCache<t_point_type, t_weight_type>(weight_cutoff)
            , geo(geo)
            , position_column(geo.column(VertexProperty::Position))
            , normal_column(t_point_type::HasNormal() ? geo.column(VertexProperty::Normal) : geo.column(VertexProperty::Position))
            , color_column(t_point_type::HasColor() ? geo.column(VertexProperty::Color) : geo.column(VertexProperty::Position))
            , flag_column([&geo]()->TableColumn& { geo.ensureFlagColumnExists(); return geo.column(VertexProperty::BitFlag); }())
            , weight_column(geo.propertyColumn("intensity"))
            , geo_vertex_offset(geo.vertexOffset())
            , geo_vertex_add_offset(geo.vertexCount())
            , lock_ptr(lock_ptr)
        {}
        
        Geometry geo;
        TableColumn& position_column;
        TableColumn& normal_column;
        TableColumn& color_column;
        TableColumn& flag_column;
        TableColumn& weight_column;
        uint04 geo_vertex_offset;
        uint04 geo_vertex_add_offset;
        const void* lock_ptr;
    };

    template<class t_point_type, class t_weight_type>
    class BlockModelFilteringCache
    {
    public:
        BlockModelFilteringCache() {}
        virtual ~BlockModelFilteringCache() {}
        virtual bool shouldFilter(const Vertex<3, uint04>& location, const t_point_type& node, t_weight_type weight) const = 0;
        virtual void onFiltered(const Vertex<3, uint04>& location, const t_point_type& node, t_weight_type weight) const = 0;
        virtual IntersectionTypes classifyToFilter(const Bounds<3, uint04>& value) const = 0;
    };

    template<class t_point_type, uint04 t_size, class t_weight_type>
    class BlockModelRaster : public BlockLookupNode<t_size, uint04>
    {
    public:
        class RasterBuffer
        {
        public:
            inline BlockModelRaster<t_point_type, t_size, t_weight_type>& operator[](uint04 index)
            {
                uint04 size = m_safe_rasters.size();
                if (index < size)
                    return m_safe_rasters[index];
                else
                    return m_edit_rasters[index - size];
            }
            inline const BlockModelRaster<t_point_type, t_size, t_weight_type>& operator[](uint04 index) const
            {
                uint04 size = m_safe_rasters.size();
                if (index < size)
                    return m_safe_rasters[index];
                else
                    return m_edit_rasters[index - size];
            }
            
            inline void init()
            {
                m_safe_rasters.ensureCapacity(t_size * t_size * t_size);
                m_edit_rasters.ensureCapacity(t_size * t_size);
            }
            void clear()
            {
                m_safe_rasters.clear();
                m_edit_rasters.clear();
            }
            inline void add(const BlockModelRaster<t_point_type, t_size, t_weight_type>& value)
            {
                if (m_safe_rasters.capacity() > m_safe_rasters.size())
                    m_safe_rasters.add(value);
                else
                    m_edit_rasters.add(value);
            }
            inline void sync()
            {
                if (m_edit_rasters.size() == 0)
                    return;//no new rasters
 
                m_adding_cache = true;
                if (!m_using_safe)
                    m_safe_rasters.ensureCapacity(((m_safe_rasters.size() * 3) / 2) + 4U * m_edit_rasters.size());
                m_adding_cache = false;
                uint04 safe_initial_size = m_safe_rasters.size();
                uint04 available_space = m_safe_rasters.capacity() - safe_initial_size;
                if (available_space == 0)
                    return;//no available memory
                const uint04 add_size = getMin<uint04>(available_space, m_edit_rasters.size());
                m_safe_rasters.template addSpace<false>(add_size);
                for (uint04 i = 0; i < add_size; i++)
                    m_safe_rasters[safe_initial_size + i] = m_edit_rasters[i];
                m_edit_rasters.removeIndices(0, add_size);
            }
            inline uint04 size() const
            {
                return m_safe_rasters.size() + m_edit_rasters.size();
            }
            inline uint04 safeSize() const
            {
                return m_safe_rasters.size();
            }
            inline bool requestUsingSafe(bool using_safe)
            {
                if (using_safe)
                {
                    m_using_safe = true;
                    if (m_adding_cache)
                    {
                        m_using_safe = false;
                        return false;
                    }
                }
                m_using_safe = using_safe;
                return true;
            }
            inline void forceUsingSafe()
            {
                m_using_safe = true;
                for (;;)
                {
                    if (!m_adding_cache)
                        break;
                }
            }
        protected:
            PrimitiveBuffer<BlockModelRaster<t_point_type, t_size, t_weight_type>> m_safe_rasters;
            PrimitiveBuffer<BlockModelRaster<t_point_type, t_size, t_weight_type>> m_edit_rasters;
            volatile bool m_adding_cache = false;
            volatile bool m_using_safe = false;
        };
        struct SurfacingCache
        {
            SurfacingCache(GeometrySurfacingParameters& parameters, const RasterBuffer& rasters)
                : grid(t_size, t_size, t_size)
                , mc33(grid)
                , parameters(parameters)
                , rasters(rasters)
            {}
            _GRD<t_point_type> grid;
            MC33<t_point_type> mc33;
            GeometrySurfacingParameters& parameters;
            const RasterBuffer& rasters;
            t_weight_type weight_cutoff;
        };
        struct RasterNode
        {
            RasterNode(BlockModelRaster<t_point_type, t_size, t_weight_type>& geo, uint04 initial_reserve_count)
                : raster(geo)
                , vertex_index(initial_reserve_count)
            {}
            inline void updateColorAverage(const RGBColor color, uint08 weight)
            {
                raster.updateColorAverage(vertex_index, color, weight);
            }
            BlockModelRaster<t_point_type, t_size, t_weight_type>& raster;
            uint04 vertex_index;
        };
        BlockModelRaster(const Vector<3, uint04>& location)
            : location(location)
        {
            for (uint04 i = 0; i < Size(); i++)
                weight_information[i] = t_weight_type(0U);
        }
        Bounds<3, uint04> bounds() const
        {
            return Bounds<3, uint04>(location, location + t_size);
        }
        inline void updateColorAverage(uint04 index, const t_point_type color)
        {
            if (weight_information[index] == 0)
                point_count++;
            else if (weight_information[index] >= (Constant<t_weight_type>::Max >> 8))
                return;//Buffer full
            node_information[index] += color;
            weight_information[index]++;
            is_dirty = true;
        }
        inline void updateColorAverage(uint04 index, const t_point_type color, t_weight_type weight)
        {
            if (weight == 0)
                return;
            if (weight_information[index] == 0)
                point_count++;
            t_weight_type new_weight = weight_information[index] + weight;
            if (new_weight > (Constant<t_weight_type>::Max >> 8))
                return;//Buffer full
            node_information[index] = combine(node_information[index], weight_information[index], color, weight);
            weight_information[index] = new_weight;
            is_dirty = true;
        }
        inline void addWeight(uint04 index, t_weight_type weight)
        {
            if (weight_information[index] == 0)
                return;//cant add weight to something that doesn't yet exist
            weight_information[index] += weight;
            is_dirty = true;
        }
        inline void subtractWeight(uint04 index, t_weight_type weight)
        {
            if (weight_information[index] == 0)
                return;
            weight_information[index] = getMin(weight_information[index], weight);
            if (weight_information[index] == 0)
                point_count--;
            is_dirty = true;
        }
        inline void removeIndex(uint04 index)
        {
            if (weight_information[index] == 0)
                return;
            node_information[index] = t_point_type();
            weight_information[index] = t_weight_type(0U);
            point_count--;
            is_dirty = true;
        }
        inline void clearAll()
        {
            for (uint04 i = 0; i < Size(); i++)
            {
                weight_information[i] = t_weight_type(0U);
                node_information[i] = t_point_type();
            }
            point_count = 0;
            is_dirty = true;
        }
        inline t_point_type colorAt(uint04 index) const
        {
            return node_information[index];
        }
        template<class t_special_weight_type>
        inline void getWeightAndColor(uint04 x, uint04 y, uint04 z, const RasterBuffer& rasters, t_point_type& color, t_special_weight_type& value)
        {
            const Vector<3, uint04> index_offset(x % t_size, y % t_size, z % t_size);
            const uint04 index = BlockLookupNode<t_size, uint04>::ConvertToIndex(index_offset);
            t_weight_type weight(0U);
            t_point_type point;
            if (x >= t_size)
            {
                if (y >= t_size)
                {
                    if (z >= t_size)
                    {
                        if (IsValid(corner_tri_neighbor))
                        {
                            weight = rasters[corner_tri_neighbor].weight_information[index];
                            point = rasters[corner_tri_neighbor].node_information[index];
                        }
                    }
                    else
                    {
                        if (IsValid(corner_neighbors[Z]))
                        {
                            weight = rasters[corner_neighbors[Z]].weight_information[index];
                            point = rasters[corner_neighbors[Z]].node_information[index];
                        }
                    }
                }
                else if (z >= t_size)
                {
                    if (IsValid(corner_neighbors[Y]))
                    {
                        weight = rasters[corner_neighbors[Y]].weight_information[index];
                        point = rasters[corner_neighbors[Y]].node_information[index];
                    }
                }
                else
                {
                    if (IsValid(upper_neighbors[X]))
                    {
                        weight = rasters[upper_neighbors[X]].weight_information[index];
                        point = rasters[upper_neighbors[X]].node_information[index];
                    }
                }
            }
            else if (y >= t_size)
            {
                if (z >= t_size)
                {
                    if (IsValid(corner_neighbors[X]))
                    {
                        weight = rasters[corner_neighbors[X]].weight_information[index];
                        point = rasters[corner_neighbors[X]].node_information[index];
                    }
                }
                else
                {
                    if (IsValid(upper_neighbors[Y]))
                    {
                        weight = rasters[upper_neighbors[Y]].weight_information[index];
                        point = rasters[upper_neighbors[Y]].node_information[index];
                    }
                }
            }
            else if (z >= t_size)
            {
                if (IsValid(upper_neighbors[Z]))
                {
                    weight = rasters[upper_neighbors[Z]].weight_information[index];
                    point = rasters[upper_neighbors[Z]].node_information[index];
                }
            }
            else
            {
                weight = weight_information[index];
                point = node_information[index];
            }
            if (weight == 0)
            {
                color = t_point_type();
                value = t_special_weight_type(0);
            }
            else
            {
                color = point;
                value = t_special_weight_type(weight);
            }
        }
        inline void calculateTriangulation(SurfacingCache& cache)
        {
            if (point_count == 0)
                return;
            for (uint04 z = 0; z < t_size; z++)
            {
                for (uint04 y = 0; y < t_size; y++)
                {
                    for (uint04 x = 0; x < t_size; x++)
                    {
                        const uint04 index = BlockLookupNode<t_size, uint04>::ConvertToIndex(x, y, z);
                        cache.grid.nodes[x][y][z] = node_information[index];
                        cache.grid.values[x][y][z] = cast<GRD_data_type>(weight_information[index]);
                    }
 
                    getWeightAndColor(t_size, y, z, cache.rasters, cache.grid.nodes[t_size][y][z], cache.grid.values[t_size][y][z]);
                }
                for (uint04 x = 0; x < t_size + 1; x++)
                    getWeightAndColor(x, t_size, z, cache.rasters, cache.grid.nodes[x][t_size][z], cache.grid.values[x][t_size][z]);
            }
            for (uint04 y = 0; y < t_size + 1; y++)
            {
                for (uint04 x = 0; x < t_size + 1; x++)
                {
                    getWeightAndColor(x, y, t_size, cache.rasters, cache.grid.nodes[x][y][t_size], cache.grid.values[x][y][t_size]);
                }
            }
            for (uint04 i = 0; i < 2; i++)
            {
                for (uint04 z = 0; z < t_size + 1; z++)
                {
                    for (uint04 y = 0; y < t_size + 1; y++)
                    {
                        for (uint04 x = 0; x < t_size + 1; x++)
                        {
                            if (cache.grid.values[x][y][z] == 0)
                            {
                                if (z < t_size && cache.grid.values[x][y][z + 1] != 0)
                                {
                                    cache.grid.nodes[x][y][z] = cache.grid.nodes[x][y][z + 1];
                                }
                                else if (y < t_size && cache.grid.values[x][y + 1][z] != 0)
                                {
                                    cache.grid.nodes[x][y][z] = cache.grid.nodes[x][y + 1][z];
                                }
                                else if (x < t_size && cache.grid.values[x + 1][y][z] != 0)
                                {
                                    cache.grid.nodes[x][y][z] = cache.grid.nodes[x + 1][y][z];
                                }
                                else if (z > 0 && cache.grid.values[x][y][z - 1] != 0)
                                {
                                    cache.grid.nodes[x][y][z] = cache.grid.nodes[x][y][z - 1];
                                }
                                else if (y > 0 && cache.grid.values[x][y - 1][z] != 0)
                                {
                                    cache.grid.nodes[x][y][z] = cache.grid.nodes[x][y - 1][z];
                                }
                                else if (x > 0 && cache.grid.values[x - 1][y][z] != 0)
                                {
                                    cache.grid.nodes[x][y][z] = cache.grid.nodes[x - 1][y][z];
                                }
                            }
                        }
                    }
                }
            }
            //cache.grid.smooth();
            //cache.grid.smooth();
            CubeTriangulation::calculate_isosurface(cache.mc33, cast<fltp04>(cache.weight_cutoff) - 0.1f);
 
            uint04 vertex_offset = cache.parameters.surface_positions.size();
            cache.parameters.surface_positions.template addSpace<true>(cache.mc33.nV);
            //cache.parameters.surface_normals.template addSpace<true>(cache.mc33.nV);
            if constexpr (t_point_type::HasColor())
                cache.parameters.surface_colors.template addSpace<true>(cache.mc33.nV);
            Vertex<3, fltp04> location_f = location.as<3, fltp04>();
 
            for (uint04 i = 0; i < cache.mc33.nV; i++)
            {
                Vertex<3, fltp04> location_offset(cache.mc33.V[i][2], cache.mc33.V[i][1], cache.mc33.V[i][0]);
                if constexpr (t_point_type::HasColor())
                    cache.parameters.surface_colors[i + vertex_offset] = cache.mc33.C[i].color();
                cache.parameters.surface_positions[i + vertex_offset] = location_f + location_offset;
                if constexpr (t_point_type::HasOffset())
                    cache.parameters.surface_positions[i + vertex_offset] += cache.mc33.C[i].offset();
                //cache.parameters.surface_normals[i + vertex_offset] = Ray<3, fltp04>(cache.mc33.N[i][2], cache.mc33.N[i][1], cache.mc33.N[i][0]);
            }
            uint04 tri_offset = cache.parameters.surface_triangles.size();
            cache.parameters.surface_triangles.template addSpace<true>(cache.mc33.nT);
            for (uint04 i = 0; i < cache.mc33.nT; i++)
            {
                Vector<3, uint04> tri(cache.mc33.T[i][0], cache.mc33.T[i][1], cache.mc33.T[i][2]);
                if (IsValid(tri))
                    tri += vertex_offset;
                else
                    tri = Constant<Vector<3, uint04>>::Invalid;
                cache.parameters.surface_triangles[i + tri_offset] = tri;
            }
        }
        inline bool isVertexValid(uint04 x, uint04 y, uint04 z)
        {
            BlockLookupNode<t_size, t_weight_type>::indices[BlockLookupNode<t_size, uint04>::ConvertToIndex(x, y, z)] > 0;
        }
        template<bool t_set_indices>
        inline void collectAllPositions(BlockModelCache<t_point_type, t_weight_type>& cache) noexcept
        {
            if (point_count == 0)
                return;
            if (t_set_indices)
                is_dirty = false;
            for (uint04 i = 0; i < Size(); i++)
            {
                if (weight_information[i] >= cache.weight_cutoff)
                {
                    if constexpr (t_set_indices)
                        BlockLookupNode<t_size, t_weight_type>::indices[i] = cache.geo_add_locations.size();
                    cache.geo_add_locations.add((location + BlockLookupNode<t_size, uint04>::ConvertFromIndex(i)));
                    cache.geo_add_info.add(node_information[i]);
                    cache.geo_add_weight.add(weight_information[i]);
                }
            }
        }
        inline void collectNewPositions(BlockModelGeometryCache<t_point_type, t_weight_type>& cache) noexcept
        {
            if (!is_dirty || point_count == 0)
                return;
            for (uint04 i = 0; i < Size(); i++)
            {
                if (weight_information[i] >= cache.weight_cutoff)
                {
                    if (IsInvalid(BlockLookupNode<t_size, t_weight_type>::indices[i]))
                    {
                        BlockLookupNode<t_size, t_weight_type>::indices[i] = cache.geo_vertex_add_offset + cache.geo_add_locations.size();
                        cache.geo_add_locations.add((location + BlockLookupNode<t_size, uint04>::ConvertFromIndex(i)));
                        cache.geo_add_info.add(node_information[i]);
                        cache.geo_add_weight.add(weight_information[i]);
                    }
                }
            }
        }
        inline bool filterGeometries(BlockModelFilteringCache<t_point_type, t_weight_type>& filter) noexcept
        {
            if (point_count == 0)
                return false;
            switch (filter.classifyToFilter(bounds()))
            {
            case IntersectionTypes::e_outside:
                return false;
            case IntersectionTypes::e_inside:
            {
                //find the points that need to be filtered
                for (uint04 i = 0; i < Size(); i++)
                {
                    if (weight_information[i] > 0)
                    {
                        Vector<3, uint04> vertex_location = (BlockLookupNode<t_size, uint04>::ConvertFromIndex(i) + location);
                        filter.onFiltered(vertex_location, node_information[i], weight_information[i]);
                        node_information[i] = t_point_type(); 
                        weight_information[i] = cast<t_weight_type>(0U);
                    }
                }
                point_count = 0;
                is_dirty = true;
                return true;
            } break;
            case IntersectionTypes::e_mixed:
            {
                for (uint04 i = 0; i < Size(); i++)
                {
                    if (weight_information[i] > 0)
                    {
                        Vector<3, uint04> vertex_location = (BlockLookupNode<t_size, uint04>::ConvertFromIndex(i) + location);
                        if (filter.shouldFilter(vertex_location, node_information[i], weight_information[i]))
                        {
                            filter.onFiltered(vertex_location, node_information[i], weight_information[i]);
                            node_information[i] = t_point_type();
                            weight_information[i] = cast<t_weight_type>(0U);
                            point_count--;
                            is_dirty = true;
                        }
                    }
                }
                return is_dirty;
            } break;
            }
            return false;
        }
        inline void updateGeometryVertices(BlockModelGeometryCache<t_point_type, t_weight_type>& cache)
        {
            if (!is_dirty || IsInvalid(cache.geo_vertex_offset))
                return;
            //WLock lock(cache.lock_ptr);
            is_dirty = false;
            BitFlag filtered_flag(0);
            filtered_flag(cast<uint01>(VertexFlags::e_is_filtered), true);
            filtered_flag(cast<uint01>(VertexFlags::e_is_hidden), true);
            for (uint04 i = 0; i < Size(); i++)
            {
                const uint04 vert_index = BlockLookupNode<t_size, uint04>::indices[i] + cache.geo_vertex_offset;
                if (weight_information[i] >= cache.weight_cutoff)
                {
                    if (IsInvalid(vert_index))
                        continue;//Will collect this next round
                    
                    if constexpr (t_point_type::HasOffset())
                    {
                        Vector<3, fltp04> position = (location + BlockLookupNode<t_size, uint04>::ConvertFromIndex(i)).template as<3, fltp04>() + node_information[i].offset();
                        if (position != cache.position_column.template get<Vector<3, fltp04>>(vert_index))
                        {
                            cache.position_column.set(vert_index, position);
                            cache.position_update_bounds.addToBounds(vert_index);
                        }
                    }
                    if constexpr (t_point_type::HasColor())
                    {
                        RGBColor color = node_information[i].color();
                        if (color != cache.color_column.template get<RGBColor>(vert_index))
                        {
                            cache.color_column.set(vert_index, color);
                            cache.color_update_bounds.addToBounds(vert_index);
                        }
                    }
                    if constexpr (t_point_type::HasNormal())
                    {
                        Ray<3, fltp04> normal = node_information[i].normal();
                        if (normal != cache.normal_column.template get<Ray<3, fltp04>>(vert_index))
                        {
                            cache.normal_column.set(vert_index, normal);
                            cache.normal_update_bounds.addToBounds(vert_index);
                        }
                    }
                    fltp04 weight = cast<fltp04>(weight_information[i]);
                    if (weight != cache.weight_column.template get<fltp04>(vert_index))
                    {
                        cache.weight_column.set(vert_index, weight);
                        cache.weight_update_bounds.addToBounds(vert_index);
                    }
                    if (0 != cache.flag_column.template get<uint01>(vert_index))
                    {
                        cache.flag_column.set(vert_index, 0U);
                        cache.flag_update_bounds.addToBounds(vert_index);
                    }
                }
                else if (IsValid(vert_index))
                {
                    if (filtered_flag != BitFlag(cache.flag_column.template get<uint01>(vert_index)))
                    {
                        cache.flag_column.set(vert_index, filtered_flag);
                        cache.flag_update_bounds.addToBounds(vert_index);
                    }
                }
            }
        }
        constexpr static uint04 Size() { return t_size * t_size * t_size; }
        t_point_type node_information[t_size * t_size * t_size];
        t_weight_type weight_information[t_size * t_size * t_size];
        Vector<3, uint04> location;
 
        Vector<3, uint04> upper_neighbors = Constant<Vector<3, uint04>>::Invalid;
        Vector<3, uint04> corner_neighbors = Constant<Vector<3, uint04>>::Invalid;
        uint04 corner_tri_neighbor = Constant<uint04>::Invalid;
        bool is_dirty = false;
        uint04 point_count = 0;
    };
    template<class t_point_type, uint04 t_size, class t_weight_type>
    struct ObjectInfo<BlockModelRaster<t_point_type, t_size, t_weight_type>, false, true>
    {
        static const uint01 Dimensions = 0;
        static const bool Vector = true;
        static const bool Buffer = true;
        static const bool Primitive = true;
        static const bool Pointer = false;
        static const bool Unsigned = false;
        static const bool Float = false;
        static const bool Integer = false;
        static const bool Number = false;
        static const bool Enum = false;
        static const bool String = true;
        static const bool Color = false;
        static const bool Boolean = false;
        static constexpr ObjectInfo<uint01, false, false> VectorSub() { return ObjectInfo<uint01, false, false>(); }
    };
    constexpr uint04 cipow(uint04 num, uint04 pow)
    {
        return (pow >= sizeof(unsigned int) * 8) ? 0 :
            pow == 0 ? 1 : num * cipow(num, pow - 1);
    }
}