vman.h

Go to the documentation of this file.

#ifndef __VMAN_H__
#define __VMAN_H__

// VMAN_SHARED: Define this if your linking vman dynamically.
// VMAN_BUILDING_SHARED: Define this when actually building the shared library.

#if defined(VMAN_SHARED)
    #if defined(_WIN32) || defined(__CYGWIN__)
        #if defined(VMAN_BUILDING_SHARED)
            #if defined(__GNUC__)
                #define VMAN_API __attribute__ ((dllexport))
            #else
                #define VMAN_API __declspec(dllexport)
            #endif
        #else
            #if defined(__GNUC__)
                #define VMAN_API __attribute__ ((dllimport))
            #else
                #define VMAN_API __declspec(dllimport)
            #endif
        #endif
    #else
        #if (__GNUC__ >= 4)
            #define VMAN_API __attribute__ ((visibility ("default")))
        #else
            #define VMAN_API
        #endif
    #endif
#else
    #define VMAN_API
#endif

#ifdef __cplusplus
extern "C"
{
#endif


// -- Status --

typedef enum
{
    VMAN_NO_ERROR = 0,
    VMAN_OUT_OF_MEMORY
} vmanError;

VMAN_API int vmanGetError();


VMAN_API void vmanPanicExit();


enum
{
    VMAN_MAX_LAYER_NAME_LENGTH = 31
};

// -- Layer --

typedef struct
{
    const char* name;
    
    int voxelSize;
    
    int revision;

    void (*serializeFn)( const void* source, void* destination, int count );

    void (*deserializeFn)( const void* source, void* destination, int count );

    // ...
} vmanLayer;


// -- Statistics --

typedef struct
{
    int chunkGetHits;
    int chunkGetMisses;
    
    int chunkLoadOps;
    int chunkSaveOps;
    int chunkUnloadOps;

    int readOps;
    int writeOps;

    int maxLoadedChunks;
    int maxScheduledChecks;
    int maxEnqueuedJobs;
} vmanStatistics;


// -- Volume --

typedef enum
{
    VMAN_LOG_DEBUG = 0,
    VMAN_LOG_INFO,
    VMAN_LOG_WARNING,
    VMAN_LOG_ERROR
} vmanLogLevel;

typedef struct
{
    const vmanLayer* layers;

    int layerCount;

    int chunkEdgeLength;

    const char* baseDir;

    bool enableStatistics;

    void (*logFn)( vmanLogLevel level, const char* message );

} vmanVolumeParameters;


VMAN_API void vmanInitVolumeParameters( vmanVolumeParameters* parameters );



typedef void* vmanVolume;


VMAN_API vmanVolume vmanCreateVolume( const vmanVolumeParameters* parameters );


VMAN_API void vmanDeleteVolume( const vmanVolume volume );


VMAN_API void vmanSetUnusedChunkTimeout( const vmanVolume volume, int seconds );


VMAN_API void vmanSetModifiedChunkTimeout( const vmanVolume volume, int seconds );


VMAN_API void vmanResetStatistics( const vmanVolume volume );


VMAN_API bool vmanGetStatistics( const vmanVolume volume, vmanStatistics* statisticsDestination );


// -- Selection --

typedef struct
{
    int x, y, z;
    int w, h, d;
} vmanSelection;


// -- Access --

typedef enum
{
    VMAN_READ_ACCESS  = 1,
    VMAN_WRITE_ACCESS = 2
} vmanAccessMode;

typedef void* vmanAccess;

VMAN_API vmanAccess vmanCreateAccess( const vmanVolume volume );

VMAN_API void vmanDeleteAccess( const vmanAccess access );

VMAN_API void vmanSelect( vmanAccess access, const vmanSelection* selection );

VMAN_API void vmanLockAccess( vmanAccess access, int mode );


VMAN_API int vmanTryLockAccess( vmanAccess access, int mode );


VMAN_API void vmanUnlockAccess( vmanAccess access );

VMAN_API const void* vmanReadVoxelLayer( const vmanAccess access, int x, int y, int z, int layer );

VMAN_API void* vmanReadWriteVoxelLayer( const vmanAccess access, int x, int y, int z, int layer );


#ifdef __cplusplus
}
#endif

#endif