CommonDef.h

Go to the documentation of this file.

/*
 *
 *                             C@@o         ____  _____   __ _
 *                        oC8@@@@@@@o      |___ \|  __ \ / _| |
 *                    o@@@@@@@@@@@@O         __) | |  | | |_| | _____      __
 *         O@O        8@@@@@@@@@O           |__ <| |  | |  _| |/ _ \ \ /\ / /
 *       o@@@@@@@O    OOOOOCo               ___) | |__| | | | | (_) \ V  V /
 *       C@@@@@@@@@@@@Oo                   |____/|_____/|_| |_|\___/ \_/\_/
 *          o8@@@@@@@@@@@@@@@@8OOCCCC
 *              oO@@@@@@@@@@@@@@@@@@@o          3Dflow s.r.l. - www.3dflow.net
 *                   oO8@@@@@@@@@@@@o           Copyright 2022
 *       oO88@@@@@@@@8OCo                       All Rights Reserved
 *  O@@@@@@@@@@@@@@@@@@@@@@@@@8OCCoooooooCCo
 *   @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@O
 *    @@@Oo            oO8@@@@@@@@@@@@@@@@8
 *
 */
 
#ifndef FLOWENGINECOMMONDEF_H
#define FLOWENGINECOMMONDEF_H
 
#pragma once
 
#if defined( WIN32 )
#define FLE_DLL __declspec( dllexport )
#elif defined( __LINUX__ )
#define FLE_DLL __attribute__( ( visibility( "default" ) ) )
#else
#error "FlowEngine not supported on this platform!"
#endif
 
#define FLOWENGINE_FACTORY extern "C" FLE_DLL
 
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <string>
#include <vector>
#include <cassert>
#include <cmath>
 
#pragma pack( push, 8 )
 
namespace FlowEngine
{
    enum class Result : std::size_t
    {
    Success = 0,
 
    FeatureNotAvailable,
 
    GenericError,
 
    InvalidArgument,
 
    FileNotFound,
 
    BufferTooSmall,
 
    GenericIOError,
 
    ProcessNotRunning,
 
    NewVersionAvailable,
 
    OutOfMemoryError,
 
    DiskWriteError,
 
    PreconditionNotMet,
 
    UnsupportedVersion,
 
    LicenseCheckFailed,
    };
 
    using Index = std::ptrdiff_t;
 
    using Size = std::size_t;
 
    using ColorComponent = std::uint8_t;
 
    using ColorComponent32 = float;
 
    using ReconstructionID = unsigned int;
 
    template< typename T >
    struct Buffer;
 
    template< typename T >
    struct ConstBuffer;
 
    template< typename T >
    struct Buffer
    {
        T *data = nullptr;
 
        Size count = 0;
 
        Buffer() = default;
 
        Buffer( T *d, Size s )
            : data( d )
            , count( s )
        { }
 
        template< std::size_t N >
        Buffer( T( &fixedSizeArray )[ N ] )
            : data( fixedSizeArray )
            , count( N )
        { }
 
        Buffer( std::vector< T > &v )
            : data( v.empty() ? nullptr : v.data() )
            , count( v.empty() ? 0 : v.size() )
        { }
 
        Buffer( std::vector< T > &&v ) = delete;
 
        explicit operator bool() const
        {
            return data != nullptr && count != 0;
        }
 
        T *begin()
        {
            assert( data );
            return data;
        }
 
        T *end()
        {
            assert( data );
            return data + count;
        }
 
        T &operator []( std::size_t index )
        {
            assert( data );
            assert( index < count );
            return data[ index ];
        }
 
        const T &operator []( std::size_t index ) const
        {
            assert( data );
            assert( index < count );
            return data[ index ];
        }
    };
 
    template< typename T >
    struct ConstBuffer
    {
        const T *data = nullptr;
 
        Size count = 0;
 
        ConstBuffer() = default;
 
        ConstBuffer( const T *d, Size s )
            : data( d )
            , count( s )
        { }
 
        template< std::size_t N >
        ConstBuffer( const T( &fixedSizeArray )[ N ] )
            : data( fixedSizeArray )
            , count( N )
        { }
 
        ConstBuffer( const std::vector< T > &v )
            : data( v.empty() ? nullptr : v.data() )
            , count( v.empty() ? 0 : v.size() )
        { }
 
        ConstBuffer( std::vector< T > &&v ) = delete;
 
        explicit operator bool() const
        {
            return data != nullptr;
        }
 
        const T *begin() const
        {
            assert( data );
            return data;
        }
 
        const T *end() const
        {
            assert( data );
            return data + count;
        }
 
        const T &operator []( std::size_t index ) const
        {
            assert( data );
            assert( index < count );
            return data[ index ];
        }
    };
 
    template< >
    struct Buffer< char >
    {
        char *data = nullptr;
 
        Size count = 0;
 
        Buffer() = default;
 
        Buffer( std::string &str )
            : data( &str[ 0 ] )
            , count( str.size() )
        { }
 
        Buffer( char *data, Size count )
            : data( data )
            , count( count )
        { }
 
        Buffer( std::vector< char > &v )
            : data( v.empty() ? nullptr : v.data() )
            , count( v.empty() ? 0 : v.size() )
        { }
 
        Buffer( std::string &&str ) = delete;
 
        explicit operator bool() const
        {
            return data != nullptr && count != 0;
        }
    };
 
    template< >
    struct ConstBuffer< char >
    {
        const char *data = nullptr;
 
        Size count = 0;
 
        ConstBuffer() = default;
 
        ConstBuffer( const std::string &str )
            : data( str.data() )
            , count( str.size() )
        { }
 
        ConstBuffer( std::string &&str ) = delete;
 
        ConstBuffer( const char *str )
            : data( str )
            , count( std::strlen( str ) )
        { }
 
        ConstBuffer( const char *data, Size count )
            : data( data )
            , count( count )
        { }
 
        ConstBuffer( const std::vector< char > &v )
            : data( v.empty() ? nullptr : v.data() )
            , count( v.empty() ? 0 : v.size() )
        { }
 
        explicit operator bool() const
        {
            return data != nullptr && count != 0;
        }
    };
 
    template< >
    struct Buffer< void >
    {
        void *data = nullptr;
 
        Size count = 0;
 
        Buffer() = default;
 
        Buffer( void *d, Size s )
            : data( d )
            , count( s )
        { }
 
        template< typename T >
        Buffer( const Buffer< T > &other )
            : data( static_cast< void * >( other.data ) )
            , count( other.count * sizeof( T ) )
        {
 
        }
 
        explicit operator bool() const
        {
            return data != nullptr && count != 0;
        }
    };
 
    template< >
    struct ConstBuffer< void >
    {
        const void *data = nullptr;
 
        Size count = 0;
 
        ConstBuffer() = default;
 
        ConstBuffer( const void *d, Size s )
            : data( d )
            , count( s )
        { }
 
        template< typename T >
        ConstBuffer( const Buffer< T > &other )
            : data( static_cast< const void * >( other.data ) )
            , count( other.count * sizeof( T ) )
        { }
 
        template< typename T >
        ConstBuffer( const ConstBuffer< T > &other )
            : data( static_cast< const void * >( other.data ) )
            , count( other.count * sizeof( T ) )
        { }
 
        explicit operator bool() const
        {
            return data != nullptr && count != 0;
        }
    };
 
    using StringBuffer      = Buffer< char >;
    using ConstStringBuffer = ConstBuffer< char >;
 
    struct Version final
    {
        int major = 0;
 
        int minor = 0;
 
        inline bool isSameAs( const Version &other ) const
        {
            return major == other.major && minor == other.minor;
        }
 
        inline bool isOlderThan( const Version &other ) const
        {
            if ( major < other.major )
                return true;
 
            if ( major > other.major )
                return false;
 
            return minor < other.minor;
        }
    };
 
    struct Point3
    {
        double x = 0;
 
        double y = 0;
 
        double z = 0;
    };
 
    struct Point2
    {
        double x = 0;
 
        double y = 0;
    };
 
    struct Normal
    {
        float x = 0;
 
        float y = 0;
 
        float z = 0;
    };
 
    struct Color
    {
        ColorComponent r = 0;
 
        ColorComponent g = 0;
 
        ColorComponent b = 0;
    };
 
    struct PointColor32
    {
        ColorComponent32 r = 0;
 
        ColorComponent32 g = 0;
 
        ColorComponent32 b = 0;
    };
 
    using Color32 = PointColor32;
 
    struct Triangle
    {
        Index idx0 = 0;
 
        Index idx1 = 0;
 
        Index idx2 = 0;
    };
 
    struct TexCoords
    {
        float u = 0;
 
        float v = 0;
    };
 
    struct Quaternion
    {
        Point3 axis;
 
        double angle = 0;
    };
 
    struct Image
    {
        int width = 0;
 
        int height = 0;
 
        Buffer< Color32 > data;
 
        Color32 &operator ()( int x, int y ) { return data[ y * width + x ]; }
 
        const Color32 &operator ()( int x, int y ) const { return data[ y * width + x ]; }
    };
 
    enum class StandardAxis
    {
        X,
 
        Y,
 
        Z,
    };
 
    template< typename T, typename S >
    struct Pair
    {
        T first;
        S second;
    };
 
    struct DateTime
    {
        int year = 0;
 
        int month = 0;
 
        int day = 0;
 
        int hour = 0;
 
        int minute = 0;
 
        int second = 0;
    };
 
    struct Vector3
    {
        double data[ 3 ] = { };
 
        Vector3() = default;
 
        Vector3( double x, double y, double z )
        {
            data[ 0 ] = x;
            data[ 1 ] = y;
            data[ 2 ] = z;
        }
 
        double x() const { return data[ 0 ]; }
        double y() const { return data[ 1 ]; }
        double z() const { return data[ 2 ]; }
 
        double &x() { return data[ 0 ]; }
        double &y() { return data[ 1 ]; }
        double &z() { return data[ 2 ]; }
 
        double &operator ()( int index ) { return data[ index ]; }
 
        const double &operator ()( int index ) const { return data[ index ]; }
 
        double length() const
        {
            return std::sqrt( x() * x() + y() * y() + z() * z() );
        }
 
        Vector3 normalized() const
        {
            double len = length();
 
            if ( len == 0 )
                return { 0, 0, 0 };
 
            return { x() / len, y() / len, z() / len };
        }
 
        double dot( const Vector3 &other ) const
        {
            return x() * other.x() + y() * other.y() + z() * other.z();
        }
 
        Vector3 cross( const Vector3 &other ) const
        {
            return
                {
                    y() * other.z() - z() * other.y(),
                    z() * other.x() - x() * other.z(),
                    x() * other.y() - y() * other.x(),
                };
        }
 
        friend Vector3 operator *( double scalar, const Vector3 &v )
        {
            return { v.x() * scalar, v.y() * scalar, v.z() * scalar };
        }
 
        friend Vector3 operator *( const Vector3 &v, double scalar )
        {
            return scalar * v;
        }
 
        friend Vector3 operator -( const Vector3 &lhs, const Vector3 &rhs )
        {
            return { lhs.x() - rhs.x(), lhs.y() - rhs.y(), lhs.z() - rhs.z() };
        }
 
        friend Vector3 operator +( const Vector3 &lhs, const Vector3 &rhs )
        {
            return { lhs.x() + rhs.x(), lhs.y() + rhs.y(), lhs.z() + rhs.z() };
        }
    };
 
    struct Matrix3x3
    {
        double data[ 9 ] = { };
 
        Matrix3x3() = default;
 
        Matrix3x3( const double ( &inMatrix )[ 9 ] )
        {
            std::memcpy( data, inMatrix, sizeof( data ) );
        }
 
        Matrix3x3( const std::initializer_list< double > &list )
        {
            assert( list.size() == 9 );
            std::copy( list.begin(), list.end(), data );
        }
 
        double &operator ()( int row, int col ) { return data[ row * 3 + col ]; }
 
        const double &operator ()( int row, int col ) const { return data[ row * 3 + col ]; }
 
        friend Vector3 operator *( const Matrix3x3 &R, const FlowEngine::Vector3 &v )
        {
            return
                {
                    R( 0, 0 ) * v.x() + R( 0, 1 ) * v.y() + R( 0, 2 ) * v.z(),
                    R( 1, 0 ) * v.x() + R( 1, 1 ) * v.y() + R( 1, 2 ) * v.z(),
                    R( 2, 0 ) * v.x() + R( 2, 1 ) * v.y() + R( 2, 2 ) * v.z(),
                };
        }
    };
 
    struct GraphicsDeviceID
    {
        int bus = -1;
        int idx = -1;
 
        operator bool() const
        {
            return bus >= 0 && idx >= 0;
        }
    };
 
    enum class GraphicsDevicePlatform
    {
        Invalid = 0,
        CUDA    = 1,
        OpenCL  = 2,
    };
 
    struct GraphicsDeviceInfo
    {
        GraphicsDeviceID       id;
        GraphicsDevicePlatform platform         = GraphicsDevicePlatform::Invalid;
        int                    idx              = -1;
        int                    bus              = -1;
        char                   name[ 512 ]      = { };
        long long              physicalMemoryMB = 0;
        bool                   isIntegrated     = false;
    };
 
    enum PointClassificationAttributes
    {
        PointClassificationFlag_IsGround = 0x0001,
    };
 
    enum PointClassificationCategory
    {
        PointClassificationCategory_Unknown   = 0x0000,
        PointClassificationCategory_Roads     = 0x0100,
        PointClassificationCategory_Buildings = 0x0200,
        PointClassificationCategory_Trees     = 0x0400,
        PointClassificationCategory_Custom    = 0x1000,
    };
 
    using PointClassification = int;
}
 
#pragma pack( pop )
 
static_assert( sizeof( FlowEngine::Point3 ) == 3 * sizeof( double ), "Point3 layout mismatch" );
static_assert( sizeof( FlowEngine::Point2 ) == 2 * sizeof( double ), "Point2 layout mismatch" );
static_assert( sizeof( FlowEngine::Normal ) == 3 * sizeof( float ), "Normal layout mismatch" );
static_assert( sizeof( FlowEngine::Color ) == 3 * sizeof( FlowEngine::ColorComponent ), "Color layout mismatch" );
static_assert( sizeof( FlowEngine::PointColor32 ) == 3 * sizeof( float ), "PointColor32 layout mismatch" );
static_assert( sizeof( FlowEngine::Triangle ) == 3 * sizeof( FlowEngine::Index ), "Triangle layout mismatch" );
static_assert( sizeof( FlowEngine::TexCoords ) == 2 * sizeof( float ), "TexCoords layout mismatch" );
static_assert( sizeof( FlowEngine::Vector3 ) == 3 * sizeof( double ), "Vector3 layout mismatch" );
static_assert( sizeof( FlowEngine::Matrix3x3 ) == 9 * sizeof( double ), "Matrix3x3 layout mismatch" );
 
static_assert( std::is_trivially_copyable< FlowEngine::Point3 >::value, "Point3 must be trivially copyable" );
static_assert( std::is_trivially_copyable< FlowEngine::Normal >::value, "Normal must be trivially copyable" );
static_assert( std::is_trivially_copyable< FlowEngine::Color >::value, "Color must be trivially copyable" );
static_assert( std::is_trivially_copyable< FlowEngine::Triangle >::value, "Triangle must be trivially copyable" );
static_assert( std::is_trivially_copyable< FlowEngine::TexCoords >::value, "TexCoords must be trivially copyable" );
static_assert( std::is_trivially_copyable< FlowEngine::Vector3 >::value, "Vector3 must be trivially copyable" );
static_assert( std::is_trivially_copyable< FlowEngine::Matrix3x3 >::value, "Matrix3x3 must be trivially copyable" );
 
#endif