_BVH_Node_2ary_FloatingPointPacked

//Packed version of previous (`_BVH_Node_2ary_FloatingPointBasic`).
//  Crammed into one cache line by packing the pointers into the fourth components of the vectors.
ATTRIB_ALIGN_BEFORE(64) class _BVH_Node_2ary_FloatingPointPacked final {
    public:
        union {
            struct {
                uint32_t _pad0[3];
                struct Info info;
                uint8_t _pad1[3];
                uint32_t _pad2[12];
            };

            union Internal final {
                struct {
                    Math::AABB bound_child0;
                    Math::AABB bound_child1;
                };
                struct {
                    uint32_t _pad0[3]; //(child 0's lower point)
                    struct Info info; //Information byte
                    //Blank.  We could put stuff here (but e.g. extending the child indices from 6
                    //  bytes to 7 bytes would make the calculation of both more complicated (slower).
                    uint8_t _pad1[3];

                    uint32_t _pad2[3]; //(child 0's upper point)
                    uint32_t index_child0_upper; //Child 0's index's upper four bytes

                    uint32_t _pad3[3]; //(child 1's lower point)
                    uint16_t index_child0_lower; //Child 0's index's lower two bytes
                    uint16_t index_child1_upper; //Child 1's index's upper two bytes

                    uint32_t _pad4[3]; //(child 1's upper point)
                    uint32_t index_child1_lower; //Child 1's index's lower four bytes
                };

                inline Math::AABB const& get_bound_child0(void) const { return bound_child0; }
                inline Math::AABB const& get_bound_child1(void) const { return bound_child1; }
                inline _BVH_Node_2ary_FloatingPointPacked const* get_child0(void) const {
                    assert_term(!info.is_leaf,"Implementation error!"); //Not an internal node!
                    uint64_t index_child0 = static_cast<uint64_t>(index_child0_lower) | (static_cast<uint64_t>(index_child0_upper)<<16);
                    return reinterpret_cast<_BVH_Node_2ary_FloatingPointPacked const*>(this) + index_child0;
                }
                inline _BVH_Node_2ary_FloatingPointPacked const* get_child1(void) const {
                    assert_term(!info.is_leaf,"Implementation error!"); //Not an internal node!
                    uint64_t index_child1 = static_cast<uint64_t>(index_child1_lower) | (static_cast<uint64_t>(index_child1_upper)<<32);
                    return reinterpret_cast<_BVH_Node_2ary_FloatingPointPacked const*>(this) + index_child1;
                }
                inline void set_child0(_BVH_Node_2ary_FloatingPointPacked const* child0) {
                    uint64_t ichild0 = child0 - reinterpret_cast<_BVH_Node_2ary_FloatingPointPacked const*>(this);
                    index_child0_lower = static_cast<uint16_t>(ichild0    );
                    index_child0_upper = static_cast<uint32_t>(ichild0>>16);
                    assert_term(get_child0()==child0,"Implementation error!");
                }
                inline void set_child1(_BVH_Node_2ary_FloatingPointPacked const* child1) {
                    uint64_t ichild1 = child1 - reinterpret_cast<_BVH_Node_2ary_FloatingPointPacked const*>(this);
                    index_child1_lower = static_cast<uint32_t>(ichild1    );
                    index_child1_upper = static_cast<uint16_t>(ichild1>>32);
                    assert_term(get_child1()==child1,"Implementation error!");
                }
            } internal;

            union Leaf final {
                struct {
                    Math::AABB bound_child0;
                    Math::AABB bound_child1;
                };
                struct {
                    uint32_t _pad0[3]; //(child 0's lower point)
                    struct Info info; //Information byte
                    //Blank.  We could put stuff here (but e.g. extending the child indices from 6
                    //  bytes to 7 bytes would make the calculation of both more complicated (slower).
                    uint8_t _pad1[3];

                    uint32_t _pad2[3]; //(child 0's upper point)
                    uint32_t index_child0_upper; //Child 0's index's upper four bytes

                    uint32_t _pad3[3]; //(child 1's lower point)
                    uint16_t index_child0_lower; //Child 0's index's lower two bytes
                    uint16_t index_child1_upper; //Child 1's index's upper two bytes

                    uint32_t _pad4[3]; //(child 1's upper point)
                    uint32_t index_child1_lower; //Child 1's index's lower four bytes
                };

                inline Math::AABB const& get_bound_child0(void) const { return bound_child0; }
                inline Math::AABB const& get_bound_child1(void) const { return bound_child1; }
                inline Objects::ObjectBase const* get_child0(std::vector<Objects::ObjectBase*> const& objects) const {
                    assert_term(info.is_leaf,"Implementation error!"); //Not a leaf node!
                    uint64_t index_child0 = static_cast<uint64_t>(index_child0_lower) | (static_cast<uint64_t>(index_child0_upper)<<16);
                    return objects[static_cast<size_t>(index_child0)];
                }
                inline Objects::ObjectBase const* get_child1(std::vector<Objects::ObjectBase*> const& objects) const {
                    assert_term(info.is_leaf,"Implementation error!"); //Not a leaf node!
                    uint64_t index_child1 = static_cast<uint64_t>(index_child1_lower) | (static_cast<uint64_t>(index_child1_upper)<<32);
                    return objects[static_cast<size_t>(index_child1)];
                }
                inline void set_child0(std::vector<Objects::ObjectBase*> const& objects, uint64_t ichild0) {
                    index_child0_lower = static_cast<uint16_t>(ichild0    );
                    index_child0_upper = static_cast<uint32_t>(ichild0>>16);
                    assert_term(get_child0(objects)==objects[static_cast<size_t>(ichild0)],"Implementation error!");
                }
                inline void set_child1(std::vector<Objects::ObjectBase*> const& objects, uint64_t ichild1) {
                    index_child1_lower = static_cast<uint32_t>(ichild1    );
                    index_child1_upper = static_cast<uint16_t>(ichild1>>32);
                    assert_term(get_child1(objects)==objects[static_cast<size_t>(ichild1)],"Implementation error!");
                }
            } leaf;
        };

    public:
        inline _BVH_Node_2ary_FloatingPointPacked(void) {}

        inline Math::AABB get_bound(void) const {
            Math::AABB result = Math::AABB(VEC3_INFs,-VEC3_INFs);
            if (!info.is_leaf) {
                result |= internal.get_bound_child0();
                result |= internal.get_bound_child1();
            } else {
                                      result|=leaf.get_bound_child0();
                if (info.num_objs==2) result|=leaf.get_bound_child1();
            }
            return result;
        }

        inline void set_internal(_BVH_Node_2ary_FloatingPointPacked const* child0, _BVH_Node_2ary_FloatingPointPacked const* child1) {
            assert_term(child0!=child1,"Implementation error!");
            internal.bound_child0 = child0->get_bound();
            internal.bound_child1 = child1->get_bound();
            //Note needs to come after setting bounds; this data is packed inside it.
            info.set_internal();
            internal.set_child0(child0);
            internal.set_child1(child1);
        }
        inline void set_leaf    (std::vector<Objects::ObjectBase*> const& objects, uint64_t ichild0,uint64_t ichild1) {
            assert_term(ichild0!=ichild1,"Implementation error!");
            //Note `info` needs to come after setting bounds; this data is packed inside it.
            leaf.bound_child0 = objects[static_cast<size_t>(ichild0)]->get_bound_rt_alltime();
            if (ichild1!=~0ull) {
                leaf.bound_child1 = objects[static_cast<size_t>(ichild1)]->get_bound_rt_alltime();
                info.set_leaf(2);
                leaf.set_child0(objects,ichild0);
                leaf.set_child1(objects,ichild1);
            } else {
                leaf.bound_child1 = Math::AABB(VEC3_qNaNs,VEC3_qNaNs);
                info.set_leaf(1);
                leaf.set_child0(objects,ichild0);
            }
        }

        inline void print(uint32_t indent) const { _print_node(this,indent); }
} ATTRIB_ALIGN_AFTER(64);
static_assert(alignof(_BVH_Node_2ary_FloatingPointPacked)==64,"Implementation error!");
static_assert(sizeof (_BVH_Node_2ary_FloatingPointPacked)==64,"Implementation error!");