RawData.hpp

#ifndef __FIBER_PACKING_HPP
#define __FIBER_PACKING_HPP
 
#include "CreativeArrayBase.hpp"
#include <aerie/BitPacking.hpp>
 
namespace Fiber
{
 
class   FIELD_API  RawData : public MemCore::Interface<RawData>
{
        RefPtr<CreativeArrayBase>       myRawDataCreator;
 
public:
        RawData(const RefPtr<CreativeArrayBase>&RawDataCreator = nullptr);
 
        ~RawData();
 
        const RefPtr<CreativeArrayBase> &getRawCreator() const
        {
                return myRawDataCreator;
        } 
 
 
static  RefPtr<CreativeArrayBase>  getRawCreator(CreativeArrayBase&CAB)
        {
                if (RefPtr<RawData> RD = MemCore::interface_cast<RawData>(CAB))
                        return RD->getRawCreator(); 
 
                return nullptr;
        } 
 
static  const RefPtr<CreativeArrayBase>&
        getPossibleRawCreator(const RefPtr<CreativeArrayBase>&CAB)
        {
                if (CAB)
                {
                        if (RefPtr<RawData> RD = MemCore::interface_cast<RawData>(*CAB))
                        {
                                if (const RefPtr<CreativeArrayBase>&
                                    RawCAB = RD->getRawCreator() )
                                        return RawCAB;
                        } 
                }
                return CAB;
        }
 
};
 
 
struct  FIELD_API VecPacked_10_11_11 : RawData
{
        FixedArray<double,3>    Scale   = {1.0, 1.0, 1.0},
                                Offset  = {0.0, 0.0, 0.0};
 
        using Vec3Packed = Eagle::Vec3Packed; 
 
//      VecPacked_10_11_11() 
//      {}
 
        VecPacked_10_11_11(const FixedArray<double,3>&theScale,
                           const FixedArray<double,3>&theOffset)
        : Scale( theScale )
        , Offset( theOffset )
        {} 
 
        ~VecPacked_10_11_11();
                           
        RefPtr<Chunk<Vec3Packed>> pack(const RefPtr<MemCore::TypedChunkBase<FixedArray<double,3>>>&UnpackedData);
};
 
template <int N>
struct  VecPacked : RawData
{
        double          Scale[N],
                        Offset[N];
        uint16_t        bits[N];
 
};
 
 
 
} // namespace Fiber
 
#endif // FIBER_PACKING_HPP