NvParameterized.h

Go to the documentation of this file.

//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of NVIDIA CORPORATION nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Copyright (c) 2008-2018 NVIDIA Corporation. All rights reserved.
 
#ifndef NV_PARAMETERIZED_H
#define NV_PARAMETERIZED_H

#include "foundation/PxVec2.h"
#include "foundation/PxVec3.h"
#include "foundation/PxVec4.h"
#include "foundation/PxQuat.h"
#include "foundation/PxBounds3.h"
#include "foundation/PxMat44.h"
#include <stdio.h>
#include <stdarg.h>
#include <new> // for placement new

PX_PUSH_PACK_DEFAULT

namespace NvParameterized
{

class Interface;
class Traits;

enum ErrorType
{
   ERROR_NONE = 0,
   ERROR_TYPE_NOT_SUPPORTED,
   ERROR_INDEX_OUT_OF_RANGE,
   ERROR_INVALID_PARAMETER_NAME,
   ERROR_INVALID_PARAMETER_HANDLE,
   ERROR_CAST_FAILED,
   ERROR_INVALID_ENUM_VAL,
   ERROR_SYNTAX_ERROR_IN_NAME,
   ERROR_IS_LEAF_NODE,
   ERROR_RESULT_BUFFER_OVERFLOW,
   ERROR_NAME_DOES_NOT_MATCH_DEFINITION,
   ERROR_NOT_AN_ARRAY,
   ERROR_ARRAY_SIZE_IS_FIXED,
   ERROR_ARRAY_RESIZING_IS_NOT_SUPPORTED,
   ERROR_ARRAY_IS_TOO_SMALL,
   ERROR_INVALID_ARRAY_DIMENSION,
   ERROR_INVALID_ARRAY_SIZE,
   ERROR_PARAMETER_HANDLE_DOES_NOT_MATCH_CLASS,
   ERROR_MEMORY_ALLOCATION_FAILURE,
   ERROR_INVALID_REFERENCE_INCLUDE_HINT,
   ERROR_INVALID_REFERENCE_VALUE,
   ERROR_PARAMETER_HANDLE_NOT_INITIALIZED,
   ERROR_PARAMETER_DEFINITIONS_DO_NOT_MATCH,
   ERROR_HANDLE_MISSING_INTERFACE_POINTER,
   ERROR_HANDLE_INVALID_INTERFACE_POINTER,
   ERROR_INVALID_CALL_ON_NAMED_REFERENCE,
   ERROR_NOT_IMPLEMENTED,
   ERROR_OBJECT_CONSTRUCTION_FAILED,
   ERROR_MODIFY_CONST_HANDLE
};

enum DataType
{
    TYPE_UNDEFINED = 0,

    TYPE_ARRAY = 1,

    TYPE_STRUCT = 2,

    TYPE_BOOL = 3,
    TYPE_STRING = 4,

    TYPE_ENUM = 5,

    TYPE_REF = 6,

    TYPE_I8 = 7,
    TYPE_I16 = 8,
    TYPE_I32 = 9,
    TYPE_I64 = 10,

    TYPE_U8 = 11,
    TYPE_U16 = 12,
    TYPE_U32 = 13,
    TYPE_U64 = 14,

    TYPE_F32 = 15,
    TYPE_F64 = 16,

    TYPE_VEC2 = 17,
    TYPE_VEC3 = 18,
    TYPE_VEC4 = 19,
    TYPE_QUAT = 20,
    TYPE_MAT33 = 21,
    TYPE_BOUNDS3 = 23,
    TYPE_MAT44 = 24,

    TYPE_POINTER = 25,

    TYPE_TRANSFORM = 26,

    TYPE_MAT34 = 27,

    TYPE_LAST
};

class Hint
{
    public:

    virtual ~Hint() {}
    virtual const char *    name(void) const = 0;

    virtual DataType         type(void) const = 0;

    virtual    uint64_t             asUInt(void) const = 0;
    
    virtual double             asFloat(void) const = 0;

    virtual const char *    asString(void) const = 0;

    virtual bool setAsUInt(uint64_t v) = 0;

    private:
};

class Definition
{
public:

    virtual ~Definition() {}

    virtual void destroy() = 0;

    virtual int32_t                             numHints(void) const = 0;

    virtual const Hint *                    hint(int32_t index) const = 0;

    virtual const Hint *                    hint(const char *name) const = 0;

    virtual void                            setHints(const Hint **hints, int32_t n) = 0;

    virtual void                            addHint(Hint *hint) = 0;
    
    virtual const Definition *    parent(void) const = 0;

    virtual const Definition *    root(void) const = 0;

    virtual const char *                    name(void) const = 0;

    virtual const char *                    longName(void) const = 0;

    virtual const char *                    structName(void) const = 0;

    virtual DataType                        type(void) const = 0;

    virtual const char*                     typeString() const = 0;

    virtual    int32_t                             numRefVariants(void) const = 0;

    virtual    int32_t                             refVariantValIndex( const char * ref_val ) const = 0;

    virtual    const char *                     refVariantVal(int32_t index) const = 0;

    virtual int32_t                             numEnumVals(void) const = 0;

    virtual    int32_t                             enumValIndex( const char * enum_val ) const = 0;

    virtual const char *                    enumVal(int32_t index) const = 0;

    virtual void                             setEnumVals(const char **enum_vals, int32_t n) = 0;

    virtual void                             addEnumVal(const char *enum_val) = 0;

    virtual uint32_t alignment(void) const = 0;

    virtual uint32_t padding(void) const = 0;

    virtual int32_t arrayDimension(void) const = 0;

    virtual int32_t arraySize(int32_t dimension = 0) const = 0;

    virtual bool arraySizeIsFixed(void) const = 0;

    virtual bool setArraySize(int32_t size) = 0; // -1 if the size is not fixed

    virtual bool isLeaf(void) const = 0;
    
    virtual bool isIncludedRef(void) const = 0;

    virtual int32_t numChildren(void) const = 0;

    virtual const Definition *child(int32_t index) const = 0;

    virtual const Definition *child(const char *name, int32_t &index) const = 0;

    virtual void setChildren(Definition **children, int32_t n) = 0;

    virtual void addChild(Definition *child) = 0;

    virtual void setDynamicHandleIndicesMap(const uint8_t *indices, uint32_t numIndices) = 0;

    virtual const uint8_t * getDynamicHandleIndicesMap(uint32_t &outNumIndices) const = 0;

    virtual bool isSimpleType(bool simpleStructs = true, bool simpleStrings = true) const = 0;
};

class Handle
{
public:

    enum { MAX_DEPTH = 16 };

    PX_INLINE Handle(::NvParameterized::Interface *iface);

    PX_INLINE Handle(::NvParameterized::Interface &iface);

    PX_INLINE Handle(const ::NvParameterized::Interface &iface);

    PX_INLINE Handle(const Handle &param_handle);

    PX_INLINE Handle(::NvParameterized::Interface &instance, const char *longName);

    PX_INLINE Handle(const ::NvParameterized::Interface &instance, const char *longName);

    PX_INLINE const Definition *parameterDefinition(void) const { return(mParameterDefinition); }
    
    PX_INLINE int32_t numIndexes(void) const { return(mNumIndexes); }

    PX_INLINE int32_t index(int32_t i) const { return(mIndexList[i]); }

    PX_INLINE int32_t popIndex(int32_t levels = 1);

    PX_INLINE ErrorType set(const ::NvParameterized::Interface *instance, const Definition *root, const char *child_long_name);

    PX_INLINE ErrorType set(const ::NvParameterized::Interface *instance, const char *child_long_name);
    
    PX_INLINE ErrorType getParameter(const char *longName);

    PX_INLINE ErrorType set(int32_t child_index);

    PX_INLINE ErrorType getChildHandle(const ::NvParameterized::Interface *instance, const char *child_long_name, Handle &outHandle);

    PX_INLINE ErrorType getChildHandle(int32_t index, Handle &outHandle);

    PX_INLINE bool getLongName(char *str, uint32_t max_str_len) const;

    PX_INLINE void reset();

    PX_INLINE bool isConst(void) const { return(mIsConst); }

    PX_INLINE bool isValid(void) const { return(mIsValid); }

    PX_INLINE operator bool() const { return(isValid()); }

    PX_INLINE const void *userData(void) const { return(mUserData); }

    PX_INLINE void *userData(void) { return(mUserData); }

    PX_INLINE void setUserData(void *user_data) { mUserData = user_data; }

    PX_INLINE ::NvParameterized::Interface * getInterface(void) const { return mIsConst ? 0 : mInterface; }

    PX_INLINE const ::NvParameterized::Interface * getConstInterface(void) const { return mInterface; }

    PX_INLINE void setInterface(::NvParameterized::Interface *iface) { mIsConst = false; mInterface = iface; }

    PX_INLINE void setInterface(const ::NvParameterized::Interface *iface) { mIsConst = true; mInterface = (::NvParameterized::Interface *)iface; }

    PX_INLINE ErrorType initParamRef(const char *chosenRefStr = 0, bool doDestroyOld = false);

    PX_INLINE ErrorType valueToStr(char *buf, uint32_t bufSize, const char *&ret);
    
    PX_INLINE ErrorType strToValue(const char *str, const char **endptr);

    ErrorType resizeArray(int32_t new_size);

    PX_INLINE ErrorType getArraySize(int32_t &size, int32_t dimension = 0) const;

    PX_INLINE ErrorType swapArrayElements(uint32_t firstElement, uint32_t secondElement);

    // These functions wrap the raw(Get|Set)XXXXX() methods.  They deal with
    // error handling and casting.
    
    PX_INLINE ErrorType getParamBool(bool &val) const ;

    PX_INLINE ErrorType setParamBool(bool val) ;

    PX_INLINE ErrorType getParamBoolArray(bool *array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamBoolArray(const bool *array, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType getParamString(const char *&val) const ;

    PX_INLINE ErrorType setParamString(const char *val) ;

    PX_INLINE ErrorType getParamStringArray(char **array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamStringArray(const char **array, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType getParamEnum(const char *&val) const ;

    PX_INLINE ErrorType setParamEnum(const char *val) ;

    PX_INLINE ErrorType getParamEnumArray(char **array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamEnumArray(const char **array, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType getParamRef(::NvParameterized::Interface *&val) const ;

    PX_INLINE ErrorType getParamRefArray(::NvParameterized::Interface **array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamRef(::NvParameterized::Interface * val, bool doDestroyOld = false) ;

    PX_INLINE ErrorType setParamRefArray(::NvParameterized::Interface **array, int32_t n, int32_t offset = 0, bool doDestroyOld = false) ;

    PX_INLINE ErrorType getParamI8(int8_t &val) const ;

    PX_INLINE ErrorType setParamI8(int8_t val) ;

    PX_INLINE ErrorType getParamI8Array(int8_t *array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamI8Array(const int8_t *val, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType getParamI16(int16_t &val) const ;

    PX_INLINE ErrorType setParamI16(int16_t val) ;

    PX_INLINE ErrorType getParamI16Array(int16_t *array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamI16Array(const int16_t *val, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType getParamI32(int32_t &val) const ;

    PX_INLINE ErrorType setParamI32(int32_t val) ;

    PX_INLINE ErrorType getParamI32Array(int32_t *array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamI32Array(const int32_t *val, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType getParamI64(int64_t &val) const ;

    PX_INLINE ErrorType setParamI64(int64_t val) ;

    PX_INLINE ErrorType getParamI64Array(int64_t *array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamI64Array(const int64_t *val, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType getParamU8(uint8_t &val) const ;

    PX_INLINE ErrorType setParamU8(uint8_t val) ;
    
    PX_INLINE ErrorType getParamU8Array(uint8_t *array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamU8Array(const uint8_t *val, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType getParamU16(uint16_t &val) const ;

    PX_INLINE ErrorType setParamU16(uint16_t val) ;

    PX_INLINE ErrorType getParamU16Array(uint16_t *array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamU16Array(const uint16_t *array, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType getParamU32(uint32_t &val) const ;

    PX_INLINE ErrorType setParamU32(uint32_t val) ;

    PX_INLINE ErrorType getParamU32Array(uint32_t *array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamU32Array(const uint32_t *array, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType getParamU64(uint64_t &val) const ;

    PX_INLINE ErrorType setParamU64(uint64_t val) ;

    PX_INLINE ErrorType getParamU64Array(uint64_t *array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamU64Array(const uint64_t *array, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType getParamF32(float &val) const ;

    PX_INLINE ErrorType setParamF32(float val) ;

    PX_INLINE ErrorType getParamF32Array(float *array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamF32Array(const float *array, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType getParamF64(double &val) const ;

    PX_INLINE ErrorType setParamF64(double val) ;

    PX_INLINE ErrorType getParamF64Array(double *array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamF64Array(const double *array, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType setParamVec2(const physx::PxVec2 &val) ;

    PX_INLINE ErrorType getParamVec2(physx::PxVec2 &val) const ;

    PX_INLINE ErrorType getParamVec2Array(physx::PxVec2 *array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamVec2Array(const physx::PxVec2 *array, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType setParamVec3(const physx::PxVec3 &val) ;

    PX_INLINE ErrorType getParamVec3(physx::PxVec3 &val) const ;

    PX_INLINE ErrorType getParamVec3Array(physx::PxVec3 *array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamVec3Array(const physx::PxVec3 *array, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType setParamVec4(const physx::PxVec4 &val) ;

    PX_INLINE ErrorType getParamVec4(physx::PxVec4 &val) const ;

    PX_INLINE ErrorType getParamVec4Array(physx::PxVec4 *array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamVec4Array(const physx::PxVec4 *array, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType setParamQuat(const physx::PxQuat &val) ;

    PX_INLINE ErrorType getParamQuat(physx::PxQuat &val) const ;

    PX_INLINE ErrorType getParamQuatArray(physx::PxQuat *array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamQuatArray(const physx::PxQuat *array, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType setParamMat33(const physx::PxMat33 &val) ;

    PX_INLINE ErrorType getParamMat33(physx::PxMat33 &val) const ;

    PX_INLINE ErrorType getParamMat33Array(physx::PxMat33 *array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamMat33Array(const physx::PxMat33 *array, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType setParamMat44(const physx::PxMat44 &val) ;

    PX_INLINE ErrorType getParamMat44(physx::PxMat44 &val) const ;
    
    PX_INLINE ErrorType getParamMat44Array(physx::PxMat44 *array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamMat44Array(const physx::PxMat44 *array, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType setParamMat34Legacy(const float (&val)[12]) ;

    PX_INLINE ErrorType getParamMat34Legacy(float (&val)[12]) const ;
    
    PX_INLINE ErrorType getParamMat34LegacyArray(float* array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamMat34LegacyArray(const float *array, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType setParamBounds3(const physx::PxBounds3 &val) ;

    PX_INLINE ErrorType getParamBounds3(physx::PxBounds3 &val) const ;

    PX_INLINE ErrorType getParamBounds3Array(physx::PxBounds3 *array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamBounds3Array(const physx::PxBounds3 *array, int32_t n, int32_t offset = 0) ;

    PX_INLINE ErrorType setParamTransform(const physx::PxTransform &val) ;

    PX_INLINE ErrorType getParamTransform(physx::PxTransform &val) const ;
    
    PX_INLINE ErrorType getParamTransformArray(physx::PxTransform *array, int32_t n, int32_t offset = 0) const ;

    PX_INLINE ErrorType setParamTransformArray(const physx::PxTransform *array, int32_t n, int32_t offset = 0) ;


    template <typename T> PX_INLINE ErrorType setParam(const T &val);

    template <typename T> PX_INLINE ErrorType getParam(T &val) const;

    template <typename T> PX_INLINE ErrorType getParamArray(T *array, int32_t n, int32_t offset = 0) const;

    template <typename T> PX_INLINE ErrorType setParamArray(const T *array, int32_t n, int32_t offset = 0);

private:

    PX_INLINE void pushIndex(int32_t index);

    bool mIsValid, mIsConst;
    int32_t mNumIndexes;
    int32_t mIndexList[MAX_DEPTH];
    const Definition *mParameterDefinition;
    void *mUserData;
    ::NvParameterized::Interface    *mInterface;
};

class SerializationCallback
{
public:
    virtual ~SerializationCallback() {}
    virtual void preSerialize(void* userData = NULL) = 0;
};


class Interface
{
    friend class Handle;
public:

    virtual ~Interface() {}

    virtual void destroy() = 0;

    virtual void initDefaults(void) = 0;

    virtual void initRandom(void) = 0;

    virtual const char * className(void) const = 0;
    
    virtual void setClassName(const char *name) = 0;

    virtual const char * name(void) const = 0;
    
    virtual void setName(const char *name) = 0;

    virtual uint32_t version(void) const = 0;

    virtual uint16_t getMajorVersion(void) const = 0;

    virtual uint16_t getMinorVersion(void) const = 0;

    virtual const uint32_t * checksum(uint32_t &bits) const = 0;

    virtual int32_t numParameters(void) = 0;

    virtual const Definition *parameterDefinition(int32_t index) = 0;

    virtual const Definition *rootParameterDefinition(void) = 0;

    virtual const Definition *rootParameterDefinition(void) const = 0;

    virtual ErrorType getParameterHandle(const char *longName, Handle  &handle) const = 0;

    virtual ErrorType getParameterHandle(const char *longName, Handle  &handle) = 0;

    virtual void setSerializationCallback(SerializationCallback *cb, void *userData = NULL) = 0;

    virtual ErrorType callPreSerializeCallback() const = 0;


    virtual bool equals(const ::NvParameterized::Interface &obj, Handle* handlesOfInequality = NULL, uint32_t numHandlesOfInequality = 0, bool doCompareNotSerialized = true) const = 0;

    virtual bool areParamsOK(Handle *invalidHandles = NULL, uint32_t numInvalidHandles = 0) = 0;

    virtual ErrorType copy(const ::NvParameterized::Interface &src) = 0;

    virtual ErrorType clone(Interface *&nullDestObject) const = 0;

    virtual bool checkAlignments() const = 0;

protected:
    virtual ErrorType initParamRef(const Handle &handle, const char *chosenRefStr = 0, bool doDestroyOld = false) = 0;

    // These functions wrap the raw(Get|Set)XXXXX() methods.  They deal with
    // error handling and casting.

    virtual ErrorType getParamBool(const Handle &handle, bool &val) const = 0;

    virtual ErrorType setParamBool(const Handle &handle, bool val) = 0;

    virtual ErrorType getParamBoolArray(const Handle &handle, bool *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamBoolArray(const Handle &handle, const bool *array, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType getParamString(const Handle &handle, const char *&val) const = 0;

    virtual ErrorType setParamString(const Handle &handle, const char *val) = 0;

    virtual ErrorType getParamStringArray(const Handle &handle, char **array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamStringArray(const Handle &handle, const char **array, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType getParamEnum(const Handle &handle, const char *&val) const = 0;

    virtual ErrorType setParamEnum(const Handle &handle, const char *val) = 0;

    virtual ErrorType getParamEnumArray(const Handle &handle, char **array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamEnumArray(const Handle &handle, const char **array, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType getParamRef(const Handle &handle, ::NvParameterized::Interface *&val) const = 0;

    virtual ErrorType getParamRefArray(const Handle &handle, ::NvParameterized::Interface **array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamRef(const Handle &handle, ::NvParameterized::Interface * val, bool doDestroyOld = false) = 0;

    virtual ErrorType setParamRefArray(const Handle &handle, /*const*/ ::NvParameterized::Interface **array, int32_t n, int32_t offset = 0, bool doDestroyOld = false) = 0;

    virtual ErrorType getParamI8(const Handle &handle, int8_t &val) const = 0;

    virtual ErrorType setParamI8(const Handle &handle, int8_t val) = 0;

    virtual ErrorType getParamI8Array(const Handle &handle, int8_t *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamI8Array(const Handle &handle, const int8_t *val, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType getParamI16(const Handle &handle, int16_t &val) const = 0;

    virtual ErrorType setParamI16(const Handle &handle, int16_t val) = 0;

    virtual ErrorType getParamI16Array(const Handle &handle, int16_t *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamI16Array(const Handle &handle, const int16_t *val, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType getParamI32(const Handle &handle, int32_t &val) const = 0;

    virtual ErrorType setParamI32(const Handle &handle, int32_t val) = 0;

    virtual ErrorType getParamI32Array(const Handle &handle, int32_t *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamI32Array(const Handle &handle, const int32_t *val, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType getParamI64(const Handle &handle, int64_t &val) const = 0;

    virtual ErrorType setParamI64(const Handle &handle, int64_t val) = 0;

    virtual ErrorType getParamI64Array(const Handle &handle, int64_t *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamI64Array(const Handle &handle, const int64_t *val, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType getParamU8(const Handle &handle, uint8_t &val) const = 0;

    virtual ErrorType setParamU8(const Handle &handle, uint8_t val) = 0;

    virtual ErrorType getParamU8Array(const Handle &handle, uint8_t *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamU8Array(const Handle &handle, const uint8_t *val, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType getParamU16(const Handle &handle, uint16_t &val) const = 0;

    virtual ErrorType setParamU16(const Handle &handle, uint16_t val) = 0;

    virtual ErrorType getParamU16Array(const Handle &handle, uint16_t *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamU16Array(const Handle &handle, const uint16_t *array, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType getParamU32(const Handle &handle, uint32_t &val) const = 0;

    virtual ErrorType setParamU32(const Handle &handle, uint32_t val) = 0;

    virtual ErrorType getParamU32Array(const Handle &handle, uint32_t *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamU32Array(const Handle &handle, const uint32_t *array, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType getParamU64(const Handle &handle, uint64_t &val) const = 0;

    virtual ErrorType setParamU64(const Handle &handle, uint64_t val) = 0;

    virtual ErrorType getParamU64Array(const Handle &handle, uint64_t *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamU64Array(const Handle &handle, const uint64_t *array, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType getParamF32(const Handle &handle, float &val) const = 0;

    virtual ErrorType setParamF32(const Handle &handle, float val) = 0;

    virtual ErrorType getParamF32Array(const Handle &handle, float *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamF32Array(const Handle &handle, const float *array, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType getParamF64(const Handle &handle, double &val) const = 0;

    virtual ErrorType setParamF64(const Handle &handle, double val) = 0;

    virtual ErrorType getParamF64Array(const Handle &handle, double *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamF64Array(const Handle &handle, const double *array, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType setParamVec2(const Handle &handle, const physx::PxVec2 &val) = 0;

    virtual ErrorType getParamVec2(const Handle &handle, physx::PxVec2 &val) const = 0;

    virtual ErrorType getParamVec2Array(const Handle &handle, physx::PxVec2 *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamVec2Array(const Handle &handle, const physx::PxVec2 *array, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType setParamVec3(const Handle &handle, const physx::PxVec3 &val) = 0;

    virtual ErrorType getParamVec3(const Handle &handle, physx::PxVec3 &val) const = 0;

    virtual ErrorType getParamVec3Array(const Handle &handle, physx::PxVec3 *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamVec3Array(const Handle &handle, const physx::PxVec3 *array, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType setParamVec4(const Handle &handle, const physx::PxVec4 &val) = 0;

    virtual ErrorType getParamVec4(const Handle &handle, physx::PxVec4 &val) const = 0;

    virtual ErrorType getParamVec4Array(const Handle &handle, physx::PxVec4 *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamVec4Array(const Handle &handle, const physx::PxVec4 *array, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType setParamQuat(const Handle &handle, const physx::PxQuat &val) = 0;

    virtual ErrorType getParamQuat(const Handle &handle, physx::PxQuat &val) const = 0;

    virtual ErrorType getParamQuatArray(const Handle &handle, physx::PxQuat *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamQuatArray(const Handle &handle, const physx::PxQuat *array, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType setParamMat33(const Handle &handle, const physx::PxMat33 &val) = 0;

    virtual ErrorType getParamMat33(const Handle &handle, physx::PxMat33 &val) const = 0;

    virtual ErrorType getParamMat33Array(const Handle &handle, physx::PxMat33 *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamMat33Array(const Handle &handle, const physx::PxMat33 *array, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType setParamMat44(const Handle &handle, const physx::PxMat44 &val) = 0;
    
    virtual ErrorType getParamMat44(const Handle &handle, physx::PxMat44 &val) const = 0;

    virtual ErrorType getParamMat44Array(const Handle &handle, physx::PxMat44 *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamMat44Array(const Handle &handle, const physx::PxMat44 *array, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType setParamMat34Legacy(const Handle &handle, const float (&val)[12]) = 0;
    
    virtual ErrorType getParamMat34Legacy(const Handle &handle, float (&val)[12]) const = 0;

    virtual ErrorType getParamMat34LegacyArray(const Handle &handle, float *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamMat34LegacyArray(const Handle &handle, const float *array, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType setParamBounds3(const Handle &handle, const physx::PxBounds3 &val) = 0;

    virtual ErrorType getParamBounds3(const Handle &handle, physx::PxBounds3 &val) const = 0;

    virtual ErrorType getParamBounds3Array(const Handle &handle, physx::PxBounds3 *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamTransform(const Handle &handle, const physx::PxTransform &val) = 0;
    
    virtual ErrorType getParamTransform(const Handle &handle, physx::PxTransform &val) const = 0;

    virtual ErrorType getParamTransformArray(const Handle &handle, physx::PxTransform *array, int32_t n, int32_t offset = 0) const = 0;

    virtual ErrorType setParamTransformArray(const Handle &handle, const physx::PxTransform *array, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType setParamBounds3Array(const Handle &handle, const physx::PxBounds3 *array, int32_t n, int32_t offset = 0) = 0;

    virtual ErrorType valueToStr(const Handle &handle, char *buf, uint32_t bufSize, const char *&ret) = 0;

    virtual ErrorType strToValue(Handle &handle,const char *str, const char **endptr) = 0; // assigns this string to the value

    virtual ErrorType resizeArray(const Handle &array_handle, int32_t new_size) = 0;

    virtual ErrorType getArraySize(const Handle &array_handle, int32_t &size, int32_t dimension = 0) const = 0;

    virtual ErrorType swapArrayElements(const Handle &array_handle, uint32_t firstElement, uint32_t secondElement) = 0;
};

} // end of namespace

#include "NvParameterized.inl" // inline the NvParamterHandle methods.

PX_POP_PACK

#endif // NV_PARAMETERIZED_H