Package org.lwjgl.assimp

Class Assimp

java.lang.Object
org.lwjgl.assimp.Assimp
public class Assimp extends Object

  • Field Details

  • Method Details

    • getLibrary

      public static SharedLibrary getLibrary()
      Returns the assimp SharedLibrary.

    • getDraco

      public static SharedLibrary getDraco()
      Returns the Draco SharedLibrary.

    • aiComponent_COLORSn

      public static int aiComponent_COLORSn(int n)
      int aiComponent_COLORSn(int n)

    • aiComponent_TEXCOORDSn

      public static int aiComponent_TEXCOORDSn(int n)
      int aiComponent_TEXCOORDSn(int n)

    • AI_DEG_TO_RAD

      public static float AI_DEG_TO_RAD(float x)
      float AI_DEG_TO_RAD(float x)

    • AI_RAD_TO_DEG

      public static float AI_RAD_TO_DEG(float x)
      float AI_RAD_TO_DEG(float x)

    • aiGetExportFormatCount

      public static long aiGetExportFormatCount()
      size_t aiGetExportFormatCount(void)

    • naiGetExportFormatDescription

      public static long naiGetExportFormatDescription(long pIndex)
      struct aiExportFormatDesc * aiGetExportFormatDescription(size_t pIndex)

    • aiGetExportFormatDescription

      public static @Nullable AIExportFormatDesc aiGetExportFormatDescription(long pIndex)
      struct aiExportFormatDesc * aiGetExportFormatDescription(size_t pIndex)

    • naiReleaseExportFormatDescription

      public static void naiReleaseExportFormatDescription(long desc)
      void aiReleaseExportFormatDescription(struct aiExportFormatDesc const * desc)

    • aiReleaseExportFormatDescription

      public static void aiReleaseExportFormatDescription(AIExportFormatDesc desc)
      void aiReleaseExportFormatDescription(struct aiExportFormatDesc const * desc)

    • naiCopyScene

      public static void naiCopyScene(long pIn, long pOut)
      void aiCopyScene(struct aiScene const * pIn, struct aiScene ** pOut)

    • aiCopyScene

      public static void aiCopyScene(AIScene pIn, PointerBuffer pOut)
      void aiCopyScene(struct aiScene const * pIn, struct aiScene ** pOut)

    • aiCopyScene

      public static @Nullable AIScene aiCopyScene(AIScene pIn)
      void aiCopyScene(struct aiScene const * pIn, struct aiScene ** pOut)

    • naiFreeScene

      public static void naiFreeScene(long pIn)
      void aiFreeScene(struct aiScene const * pIn)

    • aiFreeScene

      public static void aiFreeScene(AIScene pIn)
      void aiFreeScene(struct aiScene const * pIn)

    • naiExportScene

      public static int naiExportScene(long pScene, long pFormatId, long pFileName, int pPreProcessing)
      aiReturn aiExportScene(struct aiScene const * pScene, char const * pFormatId, char const * pFileName, unsigned int pPreProcessing)

    • aiExportScene

      public static int aiExportScene(AIScene pScene, ByteBuffer pFormatId, ByteBuffer pFileName, int pPreProcessing)
      aiReturn aiExportScene(struct aiScene const * pScene, char const * pFormatId, char const * pFileName, unsigned int pPreProcessing)

    • aiExportScene

      public static int aiExportScene(AIScene pScene, CharSequence pFormatId, CharSequence pFileName, int pPreProcessing)
      aiReturn aiExportScene(struct aiScene const * pScene, char const * pFormatId, char const * pFileName, unsigned int pPreProcessing)

    • naiExportSceneEx

      public static int naiExportSceneEx(long pScene, long pFormatId, long pFileName, long pIO, int pPreProcessing)
      aiReturn aiExportSceneEx(struct aiScene const * pScene, char const * pFormatId, char const * pFileName, struct aiFileIO const * pIO, unsigned int pPreProcessing)

    • aiExportSceneEx

      public static int aiExportSceneEx(AIScene pScene, ByteBuffer pFormatId, ByteBuffer pFileName, @Nullable AIFileIO pIO, int pPreProcessing)
      aiReturn aiExportSceneEx(struct aiScene const * pScene, char const * pFormatId, char const * pFileName, struct aiFileIO const * pIO, unsigned int pPreProcessing)

    • aiExportSceneEx

      public static int aiExportSceneEx(AIScene pScene, CharSequence pFormatId, CharSequence pFileName, @Nullable AIFileIO pIO, int pPreProcessing)
      aiReturn aiExportSceneEx(struct aiScene const * pScene, char const * pFormatId, char const * pFileName, struct aiFileIO const * pIO, unsigned int pPreProcessing)

    • naiExportSceneToBlob

      public static long naiExportSceneToBlob(long pScene, long pFormatId, int pPreProcessing)
      struct aiExportDataBlob * aiExportSceneToBlob(struct aiScene const * pScene, char const * pFormatId, unsigned int pPreProcessing)

    • aiExportSceneToBlob

      public static @Nullable AIExportDataBlob aiExportSceneToBlob(AIScene pScene, ByteBuffer pFormatId, int pPreProcessing)
      struct aiExportDataBlob * aiExportSceneToBlob(struct aiScene const * pScene, char const * pFormatId, unsigned int pPreProcessing)

    • aiExportSceneToBlob

      public static @Nullable AIExportDataBlob aiExportSceneToBlob(AIScene pScene, CharSequence pFormatId, int pPreProcessing)
      struct aiExportDataBlob * aiExportSceneToBlob(struct aiScene const * pScene, char const * pFormatId, unsigned int pPreProcessing)

    • naiReleaseExportBlob

      public static void naiReleaseExportBlob(long pData)
      void aiReleaseExportBlob(struct aiExportDataBlob const * pData)

    • aiReleaseExportBlob

      public static void aiReleaseExportBlob(AIExportDataBlob pData)
      void aiReleaseExportBlob(struct aiExportDataBlob const * pData)

    • naiImportFile

      public static long naiImportFile(long pFile, int pFlags)
      struct aiScene * aiImportFile(char const * pFile, unsigned int pFlags)

    • aiImportFile

      public static @Nullable AIScene aiImportFile(ByteBuffer pFile, int pFlags)
      struct aiScene * aiImportFile(char const * pFile, unsigned int pFlags)

    • aiImportFile

      public static @Nullable AIScene aiImportFile(CharSequence pFile, int pFlags)
      struct aiScene * aiImportFile(char const * pFile, unsigned int pFlags)

    • naiImportFileEx

      public static long naiImportFileEx(long pFile, int pFlags, long pFS)
      struct aiScene * aiImportFileEx(char const * pFile, unsigned int pFlags, struct aiFileIO * pFS)

    • aiImportFileEx

      public static @Nullable AIScene aiImportFileEx(ByteBuffer pFile, int pFlags, @Nullable AIFileIO pFS)
      struct aiScene * aiImportFileEx(char const * pFile, unsigned int pFlags, struct aiFileIO * pFS)

    • aiImportFileEx

      public static @Nullable AIScene aiImportFileEx(CharSequence pFile, int pFlags, @Nullable AIFileIO pFS)
      struct aiScene * aiImportFileEx(char const * pFile, unsigned int pFlags, struct aiFileIO * pFS)

    • naiImportFileExWithProperties

      public static long naiImportFileExWithProperties(long pFile, int pFlags, long pFS, long pProps)
      struct aiScene * aiImportFileExWithProperties(char const * pFile, unsigned int pFlags, struct aiFileIO * pFS, struct aiPropertyStore const * pProps)

    • aiImportFileExWithProperties

      public static @Nullable AIScene aiImportFileExWithProperties(ByteBuffer pFile, int pFlags, @Nullable AIFileIO pFS, AIPropertyStore pProps)
      struct aiScene * aiImportFileExWithProperties(char const * pFile, unsigned int pFlags, struct aiFileIO * pFS, struct aiPropertyStore const * pProps)

    • aiImportFileExWithProperties

      public static @Nullable AIScene aiImportFileExWithProperties(CharSequence pFile, int pFlags, @Nullable AIFileIO pFS, AIPropertyStore pProps)
      struct aiScene * aiImportFileExWithProperties(char const * pFile, unsigned int pFlags, struct aiFileIO * pFS, struct aiPropertyStore const * pProps)

    • naiImportFileFromMemory

      public static long naiImportFileFromMemory(long pBuffer, int pLength, int pFlags, long pHint)
      struct aiScene * aiImportFileFromMemory(char const * pBuffer, unsigned int pLength, unsigned int pFlags, char const * pHint)

    • aiImportFileFromMemory

      public static @Nullable AIScene aiImportFileFromMemory(ByteBuffer pBuffer, int pFlags, @Nullable ByteBuffer pHint)
      struct aiScene * aiImportFileFromMemory(char const * pBuffer, unsigned int pLength, unsigned int pFlags, char const * pHint)

    • aiImportFileFromMemory

      public static @Nullable AIScene aiImportFileFromMemory(ByteBuffer pBuffer, int pFlags, @Nullable CharSequence pHint)
      struct aiScene * aiImportFileFromMemory(char const * pBuffer, unsigned int pLength, unsigned int pFlags, char const * pHint)

    • naiImportFileFromMemoryWithProperties

      public static long naiImportFileFromMemoryWithProperties(long pBuffer, int pLength, int pFlags, long pHint, long pProps)
      struct aiScene * aiImportFileFromMemoryWithProperties(char const * pBuffer, unsigned int pLength, unsigned int pFlags, char const * pHint, struct aiPropertyStore const * pProps)

    • aiImportFileFromMemoryWithProperties

      public static @Nullable AIScene aiImportFileFromMemoryWithProperties(ByteBuffer pBuffer, int pFlags, @Nullable ByteBuffer pHint, AIPropertyStore pProps)
      struct aiScene * aiImportFileFromMemoryWithProperties(char const * pBuffer, unsigned int pLength, unsigned int pFlags, char const * pHint, struct aiPropertyStore const * pProps)

    • aiImportFileFromMemoryWithProperties

      public static @Nullable AIScene aiImportFileFromMemoryWithProperties(ByteBuffer pBuffer, int pFlags, @Nullable CharSequence pHint, AIPropertyStore pProps)
      struct aiScene * aiImportFileFromMemoryWithProperties(char const * pBuffer, unsigned int pLength, unsigned int pFlags, char const * pHint, struct aiPropertyStore const * pProps)

    • naiApplyPostProcessing

      public static long naiApplyPostProcessing(long pScene, int pFlags)
      struct aiScene * aiApplyPostProcessing(struct aiScene const * pScene, unsigned int pFlags)

    • aiApplyPostProcessing

      public static @Nullable AIScene aiApplyPostProcessing(AIScene pScene, int pFlags)
      struct aiScene * aiApplyPostProcessing(struct aiScene const * pScene, unsigned int pFlags)

    • naiGetPredefinedLogStream

      public static void naiGetPredefinedLogStream(int pStreams, long file, long __result)
      struct aiLogStream aiGetPredefinedLogStream(aiDefaultLogStream pStreams, char const * file)

    • aiGetPredefinedLogStream

      public static AILogStream aiGetPredefinedLogStream(int pStreams, @Nullable ByteBuffer file, AILogStream __result)
      struct aiLogStream aiGetPredefinedLogStream(aiDefaultLogStream pStreams, char const * file)

    • aiGetPredefinedLogStream

      public static AILogStream aiGetPredefinedLogStream(int pStreams, @Nullable CharSequence file, AILogStream __result)
      struct aiLogStream aiGetPredefinedLogStream(aiDefaultLogStream pStreams, char const * file)

    • naiAttachLogStream

      public static void naiAttachLogStream(long stream)
      void aiAttachLogStream(struct aiLogStream const * stream)

    • aiAttachLogStream

      public static void aiAttachLogStream(AILogStream stream)
      void aiAttachLogStream(struct aiLogStream const * stream)

    • aiEnableVerboseLogging

      public static void aiEnableVerboseLogging(boolean d)
      void aiEnableVerboseLogging(aiBool d)

    • naiDetachLogStream

      public static int naiDetachLogStream(long stream)
      aiReturn aiDetachLogStream(struct aiLogStream const * stream)

    • aiDetachLogStream

      public static int aiDetachLogStream(AILogStream stream)
      aiReturn aiDetachLogStream(struct aiLogStream const * stream)

    • aiDetachAllLogStreams

      public static void aiDetachAllLogStreams()
      void aiDetachAllLogStreams(void)

    • naiReleaseImport

      public static void naiReleaseImport(long pScene)
      void aiReleaseImport(struct aiScene const * pScene)

    • aiReleaseImport

      public static void aiReleaseImport(@Nullable AIScene pScene)
      void aiReleaseImport(struct aiScene const * pScene)

    • naiGetErrorString

      public static long naiGetErrorString()
      char * aiGetErrorString(void)

    • aiGetErrorString

      public static @Nullable String aiGetErrorString()
      char * aiGetErrorString(void)

    • naiIsExtensionSupported

      public static int naiIsExtensionSupported(long szExtension)
      aiBool aiIsExtensionSupported(char const * szExtension)

    • aiIsExtensionSupported

      public static boolean aiIsExtensionSupported(ByteBuffer szExtension)
      aiBool aiIsExtensionSupported(char const * szExtension)

    • aiIsExtensionSupported

      public static boolean aiIsExtensionSupported(CharSequence szExtension)
      aiBool aiIsExtensionSupported(char const * szExtension)

    • naiGetExtensionList

      public static void naiGetExtensionList(long szOut)
      void aiGetExtensionList(struct aiString * szOut)

    • aiGetExtensionList

      public static void aiGetExtensionList(AIString szOut)
      void aiGetExtensionList(struct aiString * szOut)

    • naiGetMemoryRequirements

      public static void naiGetMemoryRequirements(long pIn, long in)
      void aiGetMemoryRequirements(struct aiScene const * pIn, struct aiMemoryInfo * in)

    • aiGetMemoryRequirements

      public static void aiGetMemoryRequirements(AIScene pIn, AIMemoryInfo in)
      void aiGetMemoryRequirements(struct aiScene const * pIn, struct aiMemoryInfo * in)

    • naiGetEmbeddedTexture

      public static long naiGetEmbeddedTexture(long pIn, long filename)
      struct aiTexture * aiGetEmbeddedTexture(struct aiScene const * pIn, char const * filename)

    • aiGetEmbeddedTexture

      public static @Nullable AITexture aiGetEmbeddedTexture(AIScene pIn, ByteBuffer filename)
      struct aiTexture * aiGetEmbeddedTexture(struct aiScene const * pIn, char const * filename)

    • aiGetEmbeddedTexture

      public static @Nullable AITexture aiGetEmbeddedTexture(AIScene pIn, CharSequence filename)
      struct aiTexture * aiGetEmbeddedTexture(struct aiScene const * pIn, char const * filename)

    • naiCreatePropertyStore

      public static long naiCreatePropertyStore()
      struct aiPropertyStore * aiCreatePropertyStore(void)

    • aiCreatePropertyStore

      public static @Nullable AIPropertyStore aiCreatePropertyStore()
      struct aiPropertyStore * aiCreatePropertyStore(void)

    • naiReleasePropertyStore

      public static void naiReleasePropertyStore(long p)
      void aiReleasePropertyStore(struct aiPropertyStore * p)

    • aiReleasePropertyStore

      public static void aiReleasePropertyStore(AIPropertyStore p)
      void aiReleasePropertyStore(struct aiPropertyStore * p)

    • naiSetImportPropertyInteger

      public static void naiSetImportPropertyInteger(long store, long szName, int value)
      void aiSetImportPropertyInteger(struct aiPropertyStore * store, char const * szName, int value)

    • aiSetImportPropertyInteger

      public static void aiSetImportPropertyInteger(AIPropertyStore store, ByteBuffer szName, int value)
      void aiSetImportPropertyInteger(struct aiPropertyStore * store, char const * szName, int value)

    • aiSetImportPropertyInteger

      public static void aiSetImportPropertyInteger(AIPropertyStore store, CharSequence szName, int value)
      void aiSetImportPropertyInteger(struct aiPropertyStore * store, char const * szName, int value)

    • naiSetImportPropertyFloat

      public static void naiSetImportPropertyFloat(long store, long szName, float value)
      void aiSetImportPropertyFloat(struct aiPropertyStore * store, char const * szName, float value)

    • aiSetImportPropertyFloat

      public static void aiSetImportPropertyFloat(AIPropertyStore store, ByteBuffer szName, float value)
      void aiSetImportPropertyFloat(struct aiPropertyStore * store, char const * szName, float value)

    • aiSetImportPropertyFloat

      public static void aiSetImportPropertyFloat(AIPropertyStore store, CharSequence szName, float value)
      void aiSetImportPropertyFloat(struct aiPropertyStore * store, char const * szName, float value)

    • naiSetImportPropertyString

      public static void naiSetImportPropertyString(long store, long szName, long value)
      void aiSetImportPropertyString(struct aiPropertyStore * store, char const * szName, struct aiString const * value)

    • aiSetImportPropertyString

      public static void aiSetImportPropertyString(AIPropertyStore store, ByteBuffer szName, AIString value)
      void aiSetImportPropertyString(struct aiPropertyStore * store, char const * szName, struct aiString const * value)

    • aiSetImportPropertyString

      public static void aiSetImportPropertyString(AIPropertyStore store, CharSequence szName, AIString value)
      void aiSetImportPropertyString(struct aiPropertyStore * store, char const * szName, struct aiString const * value)

    • naiSetImportPropertyMatrix

      public static void naiSetImportPropertyMatrix(long store, long szName, long value)
      void aiSetImportPropertyMatrix(struct aiPropertyStore * store, char const * szName, struct aiMatrix4x4 const * value)

    • aiSetImportPropertyMatrix

      public static void aiSetImportPropertyMatrix(AIPropertyStore store, ByteBuffer szName, AIMatrix4x4 value)
      void aiSetImportPropertyMatrix(struct aiPropertyStore * store, char const * szName, struct aiMatrix4x4 const * value)

    • aiSetImportPropertyMatrix

      public static void aiSetImportPropertyMatrix(AIPropertyStore store, CharSequence szName, AIMatrix4x4 value)
      void aiSetImportPropertyMatrix(struct aiPropertyStore * store, char const * szName, struct aiMatrix4x4 const * value)

    • naiCreateQuaternionFromMatrix

      public static void naiCreateQuaternionFromMatrix(long quat, long mat)
      void aiCreateQuaternionFromMatrix(struct aiQuaternion * quat, struct aiMatrix3x3 const * mat)

    • aiCreateQuaternionFromMatrix

      public static void aiCreateQuaternionFromMatrix(AIQuaternion quat, AIMatrix3x3 mat)
      void aiCreateQuaternionFromMatrix(struct aiQuaternion * quat, struct aiMatrix3x3 const * mat)

    • naiDecomposeMatrix

      public static void naiDecomposeMatrix(long mat, long scaling, long rotation, long position)
      void aiDecomposeMatrix(struct aiMatrix4x4 const * mat, struct aiVector3D * scaling, struct aiQuaternion * rotation, struct aiVector3D * position)

    • aiDecomposeMatrix

      public static void aiDecomposeMatrix(AIMatrix4x4 mat, AIVector3D scaling, AIQuaternion rotation, AIVector3D position)
      void aiDecomposeMatrix(struct aiMatrix4x4 const * mat, struct aiVector3D * scaling, struct aiQuaternion * rotation, struct aiVector3D * position)

    • naiTransposeMatrix4

      public static void naiTransposeMatrix4(long mat)
      void aiTransposeMatrix4(struct aiMatrix4x4 * mat)

    • aiTransposeMatrix4

      public static void aiTransposeMatrix4(AIMatrix4x4 mat)
      void aiTransposeMatrix4(struct aiMatrix4x4 * mat)

    • naiTransposeMatrix3

      public static void naiTransposeMatrix3(long mat)
      void aiTransposeMatrix3(struct aiMatrix3x3 * mat)

    • aiTransposeMatrix3

      public static void aiTransposeMatrix3(AIMatrix3x3 mat)
      void aiTransposeMatrix3(struct aiMatrix3x3 * mat)

    • naiTransformVecByMatrix3

      public static void naiTransformVecByMatrix3(long vec, long mat)
      void aiTransformVecByMatrix3(struct aiVector3D * vec, struct aiMatrix3x3 const * mat)

    • aiTransformVecByMatrix3

      public static void aiTransformVecByMatrix3(AIVector3D vec, AIMatrix3x3 mat)
      void aiTransformVecByMatrix3(struct aiVector3D * vec, struct aiMatrix3x3 const * mat)

    • naiTransformVecByMatrix4

      public static void naiTransformVecByMatrix4(long vec, long mat)
      void aiTransformVecByMatrix4(struct aiVector3D * vec, struct aiMatrix4x4 const * mat)

    • aiTransformVecByMatrix4

      public static void aiTransformVecByMatrix4(AIVector3D vec, AIMatrix4x4 mat)
      void aiTransformVecByMatrix4(struct aiVector3D * vec, struct aiMatrix4x4 const * mat)

    • naiMultiplyMatrix4

      public static void naiMultiplyMatrix4(long dst, long src)
      void aiMultiplyMatrix4(struct aiMatrix4x4 * dst, struct aiMatrix4x4 const * src)

    • aiMultiplyMatrix4

      public static void aiMultiplyMatrix4(AIMatrix4x4 dst, AIMatrix4x4 src)
      void aiMultiplyMatrix4(struct aiMatrix4x4 * dst, struct aiMatrix4x4 const * src)

    • naiMultiplyMatrix3

      public static void naiMultiplyMatrix3(long dst, long src)
      void aiMultiplyMatrix3(struct aiMatrix3x3 * dst, struct aiMatrix3x3 const * src)

    • aiMultiplyMatrix3

      public static void aiMultiplyMatrix3(AIMatrix3x3 dst, AIMatrix3x3 src)
      void aiMultiplyMatrix3(struct aiMatrix3x3 * dst, struct aiMatrix3x3 const * src)

    • naiIdentityMatrix3

      public static void naiIdentityMatrix3(long mat)
      void aiIdentityMatrix3(struct aiMatrix3x3 * mat)

    • aiIdentityMatrix3

      public static void aiIdentityMatrix3(AIMatrix3x3 mat)
      void aiIdentityMatrix3(struct aiMatrix3x3 * mat)

    • naiIdentityMatrix4

      public static void naiIdentityMatrix4(long mat)
      void aiIdentityMatrix4(struct aiMatrix4x4 * mat)

    • aiIdentityMatrix4

      public static void aiIdentityMatrix4(AIMatrix4x4 mat)
      void aiIdentityMatrix4(struct aiMatrix4x4 * mat)

    • aiGetImportFormatCount

      public static long aiGetImportFormatCount()
      size_t aiGetImportFormatCount(void)

    • naiGetImportFormatDescription

      public static long naiGetImportFormatDescription(long pIndex)
      struct aiImporterDesc * aiGetImportFormatDescription(size_t pIndex)

    • aiGetImportFormatDescription

      public static @Nullable AIImporterDesc aiGetImportFormatDescription(long pIndex)
      struct aiImporterDesc * aiGetImportFormatDescription(size_t pIndex)

    • naiVector2AreEqual

      public static int naiVector2AreEqual(long a, long b)
      int aiVector2AreEqual(struct aiVector2D const * a, struct aiVector2D const * b)

    • aiVector2AreEqual

      public static boolean aiVector2AreEqual(AIVector2D a, AIVector2D b)
      int aiVector2AreEqual(struct aiVector2D const * a, struct aiVector2D const * b)

    • naiVector2AreEqualEpsilon

      public static int naiVector2AreEqualEpsilon(long a, long b, float epsilon)
      int aiVector2AreEqualEpsilon(struct aiVector2D const * a, struct aiVector2D const * b, float epsilon)

    • aiVector2AreEqualEpsilon

      public static boolean aiVector2AreEqualEpsilon(AIVector2D a, AIVector2D b, float epsilon)
      int aiVector2AreEqualEpsilon(struct aiVector2D const * a, struct aiVector2D const * b, float epsilon)

    • naiVector2Add

      public static void naiVector2Add(long dst, long src)
      void aiVector2Add(struct aiVector2D * dst, struct aiVector2D const * src)

    • aiVector2Add

      public static void aiVector2Add(AIVector2D dst, AIVector2D src)
      void aiVector2Add(struct aiVector2D * dst, struct aiVector2D const * src)

    • naiVector2Subtract

      public static void naiVector2Subtract(long dst, long src)
      void aiVector2Subtract(struct aiVector2D * dst, struct aiVector2D const * src)

    • aiVector2Subtract

      public static void aiVector2Subtract(AIVector2D dst, AIVector2D src)
      void aiVector2Subtract(struct aiVector2D * dst, struct aiVector2D const * src)

    • naiVector2Scale

      public static void naiVector2Scale(long dst, float s)
      void aiVector2Scale(struct aiVector2D * dst, float s)

    • aiVector2Scale

      public static void aiVector2Scale(AIVector2D dst, float s)
      void aiVector2Scale(struct aiVector2D * dst, float s)

    • naiVector2SymMul

      public static void naiVector2SymMul(long dst, long other)
      void aiVector2SymMul(struct aiVector2D * dst, struct aiVector2D const * other)

    • aiVector2SymMul

      public static void aiVector2SymMul(AIVector2D dst, AIVector2D other)
      void aiVector2SymMul(struct aiVector2D * dst, struct aiVector2D const * other)

    • naiVector2DivideByScalar

      public static void naiVector2DivideByScalar(long dst, float s)
      void aiVector2DivideByScalar(struct aiVector2D * dst, float s)

    • aiVector2DivideByScalar

      public static void aiVector2DivideByScalar(AIVector2D dst, float s)
      void aiVector2DivideByScalar(struct aiVector2D * dst, float s)

    • naiVector2DivideByVector

      public static void naiVector2DivideByVector(long dst, long v)
      void aiVector2DivideByVector(struct aiVector2D * dst, struct aiVector2D * v)

    • aiVector2DivideByVector

      public static void aiVector2DivideByVector(AIVector2D dst, AIVector2D v)
      void aiVector2DivideByVector(struct aiVector2D * dst, struct aiVector2D * v)

    • naiVector2Length

      public static float naiVector2Length(long v)
      float aiVector2Length(struct aiVector2D const * v)

    • aiVector2Length

      public static float aiVector2Length(AIVector2D v)
      float aiVector2Length(struct aiVector2D const * v)

    • naiVector2SquareLength

      public static float naiVector2SquareLength(long v)
      float aiVector2SquareLength(struct aiVector2D const * v)

    • aiVector2SquareLength

      public static float aiVector2SquareLength(AIVector2D v)
      float aiVector2SquareLength(struct aiVector2D const * v)

    • naiVector2Negate

      public static void naiVector2Negate(long dst)
      void aiVector2Negate(struct aiVector2D * dst)

    • aiVector2Negate

      public static void aiVector2Negate(AIVector2D dst)
      void aiVector2Negate(struct aiVector2D * dst)

    • naiVector2DotProduct

      public static float naiVector2DotProduct(long a, long b)
      float aiVector2DotProduct(struct aiVector2D const * a, struct aiVector2D const * b)

    • aiVector2DotProduct

      public static float aiVector2DotProduct(AIVector2D a, AIVector2D b)
      float aiVector2DotProduct(struct aiVector2D const * a, struct aiVector2D const * b)

    • naiVector2Normalize

      public static void naiVector2Normalize(long v)
      void aiVector2Normalize(struct aiVector2D * v)

    • aiVector2Normalize

      public static void aiVector2Normalize(AIVector2D v)
      void aiVector2Normalize(struct aiVector2D * v)

    • naiVector3AreEqual

      public static int naiVector3AreEqual(long a, long b)
      int aiVector3AreEqual(struct aiVector3D const * a, struct aiVector3D const * b)

    • aiVector3AreEqual

      public static boolean aiVector3AreEqual(AIVector3D a, AIVector3D b)
      int aiVector3AreEqual(struct aiVector3D const * a, struct aiVector3D const * b)

    • naiVector3AreEqualEpsilon

      public static int naiVector3AreEqualEpsilon(long a, long b, float epsilon)
      int aiVector3AreEqualEpsilon(struct aiVector3D const * a, struct aiVector3D const * b, float const epsilon)

    • aiVector3AreEqualEpsilon

      public static boolean aiVector3AreEqualEpsilon(AIVector3D a, AIVector3D b, float epsilon)
      int aiVector3AreEqualEpsilon(struct aiVector3D const * a, struct aiVector3D const * b, float const epsilon)

    • naiVector3LessThan

      public static int naiVector3LessThan(long a, long b)
      int aiVector3LessThan(struct aiVector3D const * a, struct aiVector3D const * b)

    • aiVector3LessThan

      public static boolean aiVector3LessThan(AIVector3D a, AIVector3D b)
      int aiVector3LessThan(struct aiVector3D const * a, struct aiVector3D const * b)

    • naiVector3Add

      public static void naiVector3Add(long dst, long src)
      void aiVector3Add(struct aiVector3D * dst, struct aiVector3D const * src)

    • aiVector3Add

      public static void aiVector3Add(AIVector3D dst, AIVector3D src)
      void aiVector3Add(struct aiVector3D * dst, struct aiVector3D const * src)

    • naiVector3Subtract

      public static void naiVector3Subtract(long dst, long src)
      void aiVector3Subtract(struct aiVector3D * dst, struct aiVector3D const * src)

    • aiVector3Subtract

      public static void aiVector3Subtract(AIVector3D dst, AIVector3D src)
      void aiVector3Subtract(struct aiVector3D * dst, struct aiVector3D const * src)

    • naiVector3Scale

      public static void naiVector3Scale(long dst, float s)
      void aiVector3Scale(struct aiVector3D * dst, float const s)

    • aiVector3Scale

      public static void aiVector3Scale(AIVector3D dst, float s)
      void aiVector3Scale(struct aiVector3D * dst, float const s)

    • naiVector3SymMul

      public static void naiVector3SymMul(long dst, long other)
      void aiVector3SymMul(struct aiVector3D * dst, struct aiVector3D const * other)

    • aiVector3SymMul

      public static void aiVector3SymMul(AIVector3D dst, AIVector3D other)
      void aiVector3SymMul(struct aiVector3D * dst, struct aiVector3D const * other)

    • naiVector3DivideByScalar

      public static void naiVector3DivideByScalar(long dst, float s)
      void aiVector3DivideByScalar(struct aiVector3D * dst, float const s)

    • aiVector3DivideByScalar

      public static void aiVector3DivideByScalar(AIVector3D dst, float s)
      void aiVector3DivideByScalar(struct aiVector3D * dst, float const s)

    • naiVector3DivideByVector

      public static void naiVector3DivideByVector(long dst, long v)
      void aiVector3DivideByVector(struct aiVector3D * dst, struct aiVector3D * v)

    • aiVector3DivideByVector

      public static void aiVector3DivideByVector(AIVector3D dst, AIVector3D v)
      void aiVector3DivideByVector(struct aiVector3D * dst, struct aiVector3D * v)

    • naiVector3Length

      public static float naiVector3Length(long v)
      float aiVector3Length(struct aiVector3D const * v)

    • aiVector3Length

      public static float aiVector3Length(AIVector3D v)
      float aiVector3Length(struct aiVector3D const * v)

    • naiVector3SquareLength

      public static float naiVector3SquareLength(long v)
      float aiVector3SquareLength(struct aiVector3D const * v)

    • aiVector3SquareLength

      public static float aiVector3SquareLength(AIVector3D v)
      float aiVector3SquareLength(struct aiVector3D const * v)

    • naiVector3Negate

      public static void naiVector3Negate(long dst)
      void aiVector3Negate(struct aiVector3D * dst)

    • aiVector3Negate

      public static void aiVector3Negate(AIVector3D dst)
      void aiVector3Negate(struct aiVector3D * dst)

    • naiVector3DotProduct

      public static float naiVector3DotProduct(long a, long b)
      float aiVector3DotProduct(struct aiVector3D const * a, struct aiVector3D const * b)

    • aiVector3DotProduct

      public static float aiVector3DotProduct(AIVector3D a, AIVector3D b)
      float aiVector3DotProduct(struct aiVector3D const * a, struct aiVector3D const * b)

    • naiVector3CrossProduct

      public static void naiVector3CrossProduct(long dst, long a, long b)
      void aiVector3CrossProduct(struct aiVector3D * dst, struct aiVector3D const * a, struct aiVector3D const * b)

    • aiVector3CrossProduct

      public static void aiVector3CrossProduct(AIVector3D dst, AIVector3D a, AIVector3D b)
      void aiVector3CrossProduct(struct aiVector3D * dst, struct aiVector3D const * a, struct aiVector3D const * b)

    • naiVector3Normalize

      public static void naiVector3Normalize(long v)
      void aiVector3Normalize(struct aiVector3D * v)

    • aiVector3Normalize

      public static void aiVector3Normalize(AIVector3D v)
      void aiVector3Normalize(struct aiVector3D * v)

    • naiVector3NormalizeSafe

      public static void naiVector3NormalizeSafe(long v)
      void aiVector3NormalizeSafe(struct aiVector3D * v)

    • aiVector3NormalizeSafe

      public static void aiVector3NormalizeSafe(AIVector3D v)
      void aiVector3NormalizeSafe(struct aiVector3D * v)

    • naiVector3RotateByQuaternion

      public static void naiVector3RotateByQuaternion(long v, long q)
      void aiVector3RotateByQuaternion(struct aiVector3D * v, struct aiQuaternion const * q)

    • aiVector3RotateByQuaternion

      public static void aiVector3RotateByQuaternion(AIVector3D v, AIQuaternion q)
      void aiVector3RotateByQuaternion(struct aiVector3D * v, struct aiQuaternion const * q)

    • naiMatrix3FromMatrix4

      public static void naiMatrix3FromMatrix4(long dst, long mat)
      void aiMatrix3FromMatrix4(struct aiMatrix3x3 * dst, struct aiMatrix4x4 const * mat)

    • aiMatrix3FromMatrix4

      public static void aiMatrix3FromMatrix4(AIMatrix3x3 dst, AIMatrix4x4 mat)
      void aiMatrix3FromMatrix4(struct aiMatrix3x3 * dst, struct aiMatrix4x4 const * mat)

    • naiMatrix3FromQuaternion

      public static void naiMatrix3FromQuaternion(long mat, long q)
      void aiMatrix3FromQuaternion(struct aiMatrix3x3 * mat, struct aiQuaternion const * q)

    • aiMatrix3FromQuaternion

      public static void aiMatrix3FromQuaternion(AIMatrix3x3 mat, AIQuaternion q)
      void aiMatrix3FromQuaternion(struct aiMatrix3x3 * mat, struct aiQuaternion const * q)

    • naiMatrix3AreEqual

      public static int naiMatrix3AreEqual(long a, long b)
      int aiMatrix3AreEqual(struct aiMatrix3x3 const * a, struct aiMatrix3x3 const * b)

    • aiMatrix3AreEqual

      public static boolean aiMatrix3AreEqual(AIMatrix3x3 a, AIMatrix3x3 b)
      int aiMatrix3AreEqual(struct aiMatrix3x3 const * a, struct aiMatrix3x3 const * b)

    • naiMatrix3AreEqualEpsilon

      public static int naiMatrix3AreEqualEpsilon(long a, long b, float epsilon)
      int aiMatrix3AreEqualEpsilon(struct aiMatrix3x3 const * a, struct aiMatrix3x3 const * b, float const epsilon)

    • aiMatrix3AreEqualEpsilon

      public static boolean aiMatrix3AreEqualEpsilon(AIMatrix3x3 a, AIMatrix3x3 b, float epsilon)
      int aiMatrix3AreEqualEpsilon(struct aiMatrix3x3 const * a, struct aiMatrix3x3 const * b, float const epsilon)

    • naiMatrix3Inverse

      public static void naiMatrix3Inverse(long mat)
      void aiMatrix3Inverse(struct aiMatrix3x3 * mat)

    • aiMatrix3Inverse

      public static void aiMatrix3Inverse(AIMatrix3x3 mat)
      void aiMatrix3Inverse(struct aiMatrix3x3 * mat)

    • naiMatrix3Determinant

      public static float naiMatrix3Determinant(long mat)
      float aiMatrix3Determinant(struct aiMatrix3x3 const * mat)

    • aiMatrix3Determinant

      public static float aiMatrix3Determinant(AIMatrix3x3 mat)
      float aiMatrix3Determinant(struct aiMatrix3x3 const * mat)

    • naiMatrix3RotationZ

      public static void naiMatrix3RotationZ(long mat, float angle)
      void aiMatrix3RotationZ(struct aiMatrix3x3 * mat, float angle)

    • aiMatrix3RotationZ

      public static void aiMatrix3RotationZ(AIMatrix3x3 mat, float angle)
      void aiMatrix3RotationZ(struct aiMatrix3x3 * mat, float angle)

    • naiMatrix3FromRotationAroundAxis

      public static void naiMatrix3FromRotationAroundAxis(long mat, long axis, float angle)
      void aiMatrix3FromRotationAroundAxis(struct aiMatrix3x3 * mat, struct aiVector3D const * axis, float angle)

    • aiMatrix3FromRotationAroundAxis

      public static void aiMatrix3FromRotationAroundAxis(AIMatrix3x3 mat, AIVector3D axis, float angle)
      void aiMatrix3FromRotationAroundAxis(struct aiMatrix3x3 * mat, struct aiVector3D const * axis, float angle)

    • naiMatrix3Translation

      public static void naiMatrix3Translation(long mat, long translation)
      void aiMatrix3Translation(struct aiMatrix3x3 * mat, struct aiVector2D const * translation)

    • aiMatrix3Translation

      public static void aiMatrix3Translation(AIMatrix3x3 mat, AIVector2D translation)
      void aiMatrix3Translation(struct aiMatrix3x3 * mat, struct aiVector2D const * translation)

    • naiMatrix3FromTo

      public static void naiMatrix3FromTo(long mat, long from, long to)
      void aiMatrix3FromTo(struct aiMatrix3x3 * mat, struct aiVector3D const * from, struct aiVector3D const * to)

    • aiMatrix3FromTo

      public static void aiMatrix3FromTo(AIMatrix3x3 mat, AIVector3D from, AIVector3D to)
      void aiMatrix3FromTo(struct aiMatrix3x3 * mat, struct aiVector3D const * from, struct aiVector3D const * to)

    • naiMatrix4FromMatrix3

      public static void naiMatrix4FromMatrix3(long dst, long mat)
      void aiMatrix4FromMatrix3(struct aiMatrix4x4 * dst, struct aiMatrix3x3 const * mat)

    • aiMatrix4FromMatrix3

      public static void aiMatrix4FromMatrix3(AIMatrix4x4 dst, AIMatrix3x3 mat)
      void aiMatrix4FromMatrix3(struct aiMatrix4x4 * dst, struct aiMatrix3x3 const * mat)

    • naiMatrix4FromScalingQuaternionPosition

      public static void naiMatrix4FromScalingQuaternionPosition(long mat, long scaling, long rotation, long position)
      void aiMatrix4FromScalingQuaternionPosition(struct aiMatrix4x4 * mat, struct aiVector3D const * scaling, struct aiQuaternion const * rotation, struct aiVector3D const * position)

    • aiMatrix4FromScalingQuaternionPosition

      public static void aiMatrix4FromScalingQuaternionPosition(AIMatrix4x4 mat, AIVector3D scaling, AIQuaternion rotation, AIVector3D position)
      void aiMatrix4FromScalingQuaternionPosition(struct aiMatrix4x4 * mat, struct aiVector3D const * scaling, struct aiQuaternion const * rotation, struct aiVector3D const * position)

    • naiMatrix4Add

      public static void naiMatrix4Add(long dst, long src)
      void aiMatrix4Add(struct aiMatrix4x4 * dst, struct aiMatrix4x4 const * src)

    • aiMatrix4Add

      public static void aiMatrix4Add(AIMatrix4x4 dst, AIMatrix4x4 src)
      void aiMatrix4Add(struct aiMatrix4x4 * dst, struct aiMatrix4x4 const * src)

    • naiMatrix4AreEqual

      public static int naiMatrix4AreEqual(long a, long b)
      int aiMatrix4AreEqual(struct aiMatrix4x4 const * a, struct aiMatrix4x4 const * b)

    • aiMatrix4AreEqual

      public static boolean aiMatrix4AreEqual(AIMatrix4x4 a, AIMatrix4x4 b)
      int aiMatrix4AreEqual(struct aiMatrix4x4 const * a, struct aiMatrix4x4 const * b)

    • naiMatrix4AreEqualEpsilon

      public static int naiMatrix4AreEqualEpsilon(long a, long b, float epsilon)
      int aiMatrix4AreEqualEpsilon(struct aiMatrix4x4 const * a, struct aiMatrix4x4 const * b, float const epsilon)

    • aiMatrix4AreEqualEpsilon

      public static boolean aiMatrix4AreEqualEpsilon(AIMatrix4x4 a, AIMatrix4x4 b, float epsilon)
      int aiMatrix4AreEqualEpsilon(struct aiMatrix4x4 const * a, struct aiMatrix4x4 const * b, float const epsilon)

    • naiMatrix4Inverse

      public static void naiMatrix4Inverse(long mat)
      void aiMatrix4Inverse(struct aiMatrix4x4 * mat)

    • aiMatrix4Inverse

      public static void aiMatrix4Inverse(AIMatrix4x4 mat)
      void aiMatrix4Inverse(struct aiMatrix4x4 * mat)

    • naiMatrix4Determinant

      public static float naiMatrix4Determinant(long mat)
      float aiMatrix4Determinant(struct aiMatrix4x4 const * mat)

    • aiMatrix4Determinant

      public static float aiMatrix4Determinant(AIMatrix4x4 mat)
      float aiMatrix4Determinant(struct aiMatrix4x4 const * mat)

    • naiMatrix4IsIdentity

      public static int naiMatrix4IsIdentity(long mat)
      int aiMatrix4IsIdentity(struct aiMatrix4x4 const * mat)

    • aiMatrix4IsIdentity

      public static boolean aiMatrix4IsIdentity(AIMatrix4x4 mat)
      int aiMatrix4IsIdentity(struct aiMatrix4x4 const * mat)

    • naiMatrix4DecomposeIntoScalingEulerAnglesPosition

      public static void naiMatrix4DecomposeIntoScalingEulerAnglesPosition(long mat, long scaling, long rotation, long position)
      void aiMatrix4DecomposeIntoScalingEulerAnglesPosition(struct aiMatrix4x4 const * mat, struct aiVector3D * scaling, struct aiVector3D * rotation, struct aiVector3D * position)

    • aiMatrix4DecomposeIntoScalingEulerAnglesPosition

      public static void aiMatrix4DecomposeIntoScalingEulerAnglesPosition(AIMatrix4x4 mat, AIVector3D scaling, AIVector3D rotation, AIVector3D position)
      void aiMatrix4DecomposeIntoScalingEulerAnglesPosition(struct aiMatrix4x4 const * mat, struct aiVector3D * scaling, struct aiVector3D * rotation, struct aiVector3D * position)

    • naiMatrix4DecomposeIntoScalingAxisAnglePosition

      public static void naiMatrix4DecomposeIntoScalingAxisAnglePosition(long mat, long scaling, long axis, long angle, long position)
      void aiMatrix4DecomposeIntoScalingAxisAnglePosition(struct aiMatrix4x4 const * mat, struct aiVector3D * scaling, struct aiVector3D * axis, ai_real * angle, struct aiVector3D * position)

    • aiMatrix4DecomposeIntoScalingAxisAnglePosition

      public static void aiMatrix4DecomposeIntoScalingAxisAnglePosition(AIMatrix4x4 mat, AIVector3D scaling, AIVector3D axis, FloatBuffer angle, AIVector3D position)
      void aiMatrix4DecomposeIntoScalingAxisAnglePosition(struct aiMatrix4x4 const * mat, struct aiVector3D * scaling, struct aiVector3D * axis, ai_real * angle, struct aiVector3D * position)

    • naiMatrix4DecomposeNoScaling

      public static void naiMatrix4DecomposeNoScaling(long mat, long rotation, long position)
      void aiMatrix4DecomposeNoScaling(struct aiMatrix4x4 const * mat, struct aiQuaternion * rotation, struct aiVector3D * position)

    • aiMatrix4DecomposeNoScaling

      public static void aiMatrix4DecomposeNoScaling(AIMatrix4x4 mat, AIQuaternion rotation, AIVector3D position)
      void aiMatrix4DecomposeNoScaling(struct aiMatrix4x4 const * mat, struct aiQuaternion * rotation, struct aiVector3D * position)

    • naiMatrix4FromEulerAngles

      public static void naiMatrix4FromEulerAngles(long mat, float x, float y, float z)
      void aiMatrix4FromEulerAngles(struct aiMatrix4x4 * mat, float x, float y, float z)

    • aiMatrix4FromEulerAngles

      public static void aiMatrix4FromEulerAngles(AIMatrix4x4 mat, float x, float y, float z)
      void aiMatrix4FromEulerAngles(struct aiMatrix4x4 * mat, float x, float y, float z)

    • naiMatrix4RotationX

      public static void naiMatrix4RotationX(long mat, float angle)
      void aiMatrix4RotationX(struct aiMatrix4x4 * mat, float angle)

    • aiMatrix4RotationX

      public static void aiMatrix4RotationX(AIMatrix4x4 mat, float angle)
      void aiMatrix4RotationX(struct aiMatrix4x4 * mat, float angle)

    • naiMatrix4RotationY

      public static void naiMatrix4RotationY(long mat, float angle)
      void aiMatrix4RotationY(struct aiMatrix4x4 * mat, float angle)

    • aiMatrix4RotationY

      public static void aiMatrix4RotationY(AIMatrix4x4 mat, float angle)
      void aiMatrix4RotationY(struct aiMatrix4x4 * mat, float angle)

    • naiMatrix4RotationZ

      public static void naiMatrix4RotationZ(long mat, float angle)
      void aiMatrix4RotationZ(struct aiMatrix4x4 * mat, float angle)

    • aiMatrix4RotationZ

      public static void aiMatrix4RotationZ(AIMatrix4x4 mat, float angle)
      void aiMatrix4RotationZ(struct aiMatrix4x4 * mat, float angle)

    • naiMatrix4FromRotationAroundAxis

      public static void naiMatrix4FromRotationAroundAxis(long mat, long axis, float angle)
      void aiMatrix4FromRotationAroundAxis(struct aiMatrix4x4 * mat, struct aiVector3D const * axis, float angle)

    • aiMatrix4FromRotationAroundAxis

      public static void aiMatrix4FromRotationAroundAxis(AIMatrix4x4 mat, AIVector3D axis, float angle)
      void aiMatrix4FromRotationAroundAxis(struct aiMatrix4x4 * mat, struct aiVector3D const * axis, float angle)

    • naiMatrix4Translation

      public static void naiMatrix4Translation(long mat, long translation)
      void aiMatrix4Translation(struct aiMatrix4x4 * mat, struct aiVector3D const * translation)

    • aiMatrix4Translation

      public static void aiMatrix4Translation(AIMatrix4x4 mat, AIVector3D translation)
      void aiMatrix4Translation(struct aiMatrix4x4 * mat, struct aiVector3D const * translation)

    • naiMatrix4Scaling

      public static void naiMatrix4Scaling(long mat, long scaling)
      void aiMatrix4Scaling(struct aiMatrix4x4 * mat, struct aiVector3D const * scaling)

    • aiMatrix4Scaling

      public static void aiMatrix4Scaling(AIMatrix4x4 mat, AIVector3D scaling)
      void aiMatrix4Scaling(struct aiMatrix4x4 * mat, struct aiVector3D const * scaling)

    • naiMatrix4FromTo

      public static void naiMatrix4FromTo(long mat, long from, long to)
      void aiMatrix4FromTo(struct aiMatrix4x4 * mat, struct aiVector3D const * from, struct aiVector3D const * to)

    • aiMatrix4FromTo

      public static void aiMatrix4FromTo(AIMatrix4x4 mat, AIVector3D from, AIVector3D to)
      void aiMatrix4FromTo(struct aiMatrix4x4 * mat, struct aiVector3D const * from, struct aiVector3D const * to)

    • naiQuaternionFromEulerAngles

      public static void naiQuaternionFromEulerAngles(long q, float x, float y, float z)
      void aiQuaternionFromEulerAngles(struct aiQuaternion * q, float x, float y, float z)

    • aiQuaternionFromEulerAngles

      public static void aiQuaternionFromEulerAngles(AIQuaternion q, float x, float y, float z)
      void aiQuaternionFromEulerAngles(struct aiQuaternion * q, float x, float y, float z)

    • naiQuaternionFromAxisAngle

      public static void naiQuaternionFromAxisAngle(long q, long axis, float angle)
      void aiQuaternionFromAxisAngle(struct aiQuaternion * q, struct aiVector3D const * axis, float angle)

    • aiQuaternionFromAxisAngle

      public static void aiQuaternionFromAxisAngle(AIQuaternion q, AIVector3D axis, float angle)
      void aiQuaternionFromAxisAngle(struct aiQuaternion * q, struct aiVector3D const * axis, float angle)

    • naiQuaternionFromNormalizedQuaternion

      public static void naiQuaternionFromNormalizedQuaternion(long q, long normalized)
      void aiQuaternionFromNormalizedQuaternion(struct aiQuaternion * q, struct aiVector3D const * normalized)

    • aiQuaternionFromNormalizedQuaternion

      public static void aiQuaternionFromNormalizedQuaternion(AIQuaternion q, AIVector3D normalized)
      void aiQuaternionFromNormalizedQuaternion(struct aiQuaternion * q, struct aiVector3D const * normalized)

    • naiQuaternionAreEqual

      public static int naiQuaternionAreEqual(long a, long b)
      int aiQuaternionAreEqual(struct aiQuaternion const * a, struct aiQuaternion const * b)

    • aiQuaternionAreEqual

      public static boolean aiQuaternionAreEqual(AIQuaternion a, AIQuaternion b)
      int aiQuaternionAreEqual(struct aiQuaternion const * a, struct aiQuaternion const * b)

    • naiQuaternionAreEqualEpsilon

      public static int naiQuaternionAreEqualEpsilon(long a, long b, float epsilon)
      int aiQuaternionAreEqualEpsilon(struct aiQuaternion const * a, struct aiQuaternion const * b, float const epsilon)

    • aiQuaternionAreEqualEpsilon

      public static boolean aiQuaternionAreEqualEpsilon(AIQuaternion a, AIQuaternion b, float epsilon)
      int aiQuaternionAreEqualEpsilon(struct aiQuaternion const * a, struct aiQuaternion const * b, float const epsilon)

    • naiQuaternionNormalize

      public static void naiQuaternionNormalize(long q)
      void aiQuaternionNormalize(struct aiQuaternion * q)

    • aiQuaternionNormalize

      public static void aiQuaternionNormalize(AIQuaternion q)
      void aiQuaternionNormalize(struct aiQuaternion * q)

    • naiQuaternionConjugate

      public static void naiQuaternionConjugate(long q)
      void aiQuaternionConjugate(struct aiQuaternion * q)

    • aiQuaternionConjugate

      public static void aiQuaternionConjugate(AIQuaternion q)
      void aiQuaternionConjugate(struct aiQuaternion * q)

    • naiQuaternionMultiply

      public static void naiQuaternionMultiply(long dst, long q)
      void aiQuaternionMultiply(struct aiQuaternion * dst, struct aiQuaternion const * q)

    • aiQuaternionMultiply

      public static void aiQuaternionMultiply(AIQuaternion dst, AIQuaternion q)
      void aiQuaternionMultiply(struct aiQuaternion * dst, struct aiQuaternion const * q)

    • naiQuaternionInterpolate

      public static void naiQuaternionInterpolate(long dst, long start, long end, float factor)
      void aiQuaternionInterpolate(struct aiQuaternion * dst, struct aiQuaternion const * start, struct aiQuaternion const * end, float factor)

    • aiQuaternionInterpolate

      public static void aiQuaternionInterpolate(AIQuaternion dst, AIQuaternion start, AIQuaternion end, float factor)
      void aiQuaternionInterpolate(struct aiQuaternion * dst, struct aiQuaternion const * start, struct aiQuaternion const * end, float factor)

    • naiGetImporterDesc

      public static long naiGetImporterDesc(long extension)
      struct aiImporterDesc * aiGetImporterDesc(char const * extension)

    • aiGetImporterDesc

      public static @Nullable AIImporterDesc aiGetImporterDesc(ByteBuffer extension)
      struct aiImporterDesc * aiGetImporterDesc(char const * extension)

    • aiGetImporterDesc

      public static @Nullable AIImporterDesc aiGetImporterDesc(CharSequence extension)
      struct aiImporterDesc * aiGetImporterDesc(char const * extension)

    • naiTextureTypeToString

      public static long naiTextureTypeToString(int in)
      char const * aiTextureTypeToString(aiTextureType in)

    • aiTextureTypeToString

      public static @Nullable String aiTextureTypeToString(int in)
      char const * aiTextureTypeToString(aiTextureType in)

    • naiGetMaterialProperty

      public static int naiGetMaterialProperty(long pMat, long pKey, int type, int index, long mPropOut)
      aiReturn aiGetMaterialProperty(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, struct aiMaterialProperty const ** mPropOut)

    • aiGetMaterialProperty

      public static int aiGetMaterialProperty(AIMaterial pMat, ByteBuffer pKey, int type, int index, PointerBuffer mPropOut)
      aiReturn aiGetMaterialProperty(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, struct aiMaterialProperty const ** mPropOut)

    • aiGetMaterialProperty

      public static int aiGetMaterialProperty(AIMaterial pMat, CharSequence pKey, int type, int index, PointerBuffer mPropOut)
      aiReturn aiGetMaterialProperty(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, struct aiMaterialProperty const ** mPropOut)

    • aiGetMaterialProperty

      public static int aiGetMaterialProperty(AIMaterial pMat, ByteBuffer pKey, PointerBuffer mPropOut)
      aiReturn aiGetMaterialProperty(struct aiMaterial const * pMat, char const * pKey, struct aiMaterialProperty const ** mPropOut)

    • aiGetMaterialProperty

      public static int aiGetMaterialProperty(AIMaterial pMat, CharSequence pKey, PointerBuffer mPropOut)
      aiReturn aiGetMaterialProperty(struct aiMaterial const * pMat, char const * pKey, struct aiMaterialProperty const ** mPropOut)

    • naiGetMaterialFloatArray

      public static int naiGetMaterialFloatArray(long pMat, long pKey, int type, int index, long pOut, long pMax)
      aiReturn aiGetMaterialFloatArray(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, ai_real * pOut, unsigned int * pMax)

    • aiGetMaterialFloatArray

      public static int aiGetMaterialFloatArray(AIMaterial pMat, ByteBuffer pKey, int type, int index, FloatBuffer pOut, @Nullable IntBuffer pMax)
      aiReturn aiGetMaterialFloatArray(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, ai_real * pOut, unsigned int * pMax)

    • aiGetMaterialFloatArray

      public static int aiGetMaterialFloatArray(AIMaterial pMat, CharSequence pKey, int type, int index, FloatBuffer pOut, @Nullable IntBuffer pMax)
      aiReturn aiGetMaterialFloatArray(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, ai_real * pOut, unsigned int * pMax)

    • naiGetMaterialIntegerArray

      public static int naiGetMaterialIntegerArray(long pMat, long pKey, int type, int index, long pOut, long pMax)
      aiReturn aiGetMaterialIntegerArray(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, int * pOut, unsigned int * pMax)

    • aiGetMaterialIntegerArray

      public static int aiGetMaterialIntegerArray(AIMaterial pMat, ByteBuffer pKey, int type, int index, IntBuffer pOut, @Nullable IntBuffer pMax)
      aiReturn aiGetMaterialIntegerArray(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, int * pOut, unsigned int * pMax)

    • aiGetMaterialIntegerArray

      public static int aiGetMaterialIntegerArray(AIMaterial pMat, CharSequence pKey, int type, int index, IntBuffer pOut, @Nullable IntBuffer pMax)
      aiReturn aiGetMaterialIntegerArray(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, int * pOut, unsigned int * pMax)

    • naiGetMaterialColor

      public static int naiGetMaterialColor(long pMat, long pKey, int type, int index, long pOut)
      aiReturn aiGetMaterialColor(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, struct aiColor4D * pOut)

    • aiGetMaterialColor

      public static int aiGetMaterialColor(AIMaterial pMat, ByteBuffer pKey, int type, int index, AIColor4D pOut)
      aiReturn aiGetMaterialColor(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, struct aiColor4D * pOut)

    • aiGetMaterialColor

      public static int aiGetMaterialColor(AIMaterial pMat, CharSequence pKey, int type, int index, AIColor4D pOut)
      aiReturn aiGetMaterialColor(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, struct aiColor4D * pOut)

    • naiGetMaterialUVTransform

      public static int naiGetMaterialUVTransform(long pMat, long pKey, int type, int index, long pOut)
      aiReturn aiGetMaterialUVTransform(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, struct aiUVTransform * pOut)

    • aiGetMaterialUVTransform

      public static int aiGetMaterialUVTransform(AIMaterial pMat, ByteBuffer pKey, int type, int index, AIUVTransform pOut)
      aiReturn aiGetMaterialUVTransform(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, struct aiUVTransform * pOut)

    • aiGetMaterialUVTransform

      public static int aiGetMaterialUVTransform(AIMaterial pMat, CharSequence pKey, int type, int index, AIUVTransform pOut)
      aiReturn aiGetMaterialUVTransform(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, struct aiUVTransform * pOut)

    • naiGetMaterialString

      public static int naiGetMaterialString(long pMat, long pKey, int type, int index, long pOut)
      aiReturn aiGetMaterialString(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, struct aiString * pOut)

    • aiGetMaterialString

      public static int aiGetMaterialString(AIMaterial pMat, ByteBuffer pKey, int type, int index, AIString pOut)
      aiReturn aiGetMaterialString(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, struct aiString * pOut)

    • aiGetMaterialString

      public static int aiGetMaterialString(AIMaterial pMat, CharSequence pKey, int type, int index, AIString pOut)
      aiReturn aiGetMaterialString(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, struct aiString * pOut)

    • naiGetMaterialTextureCount

      public static int naiGetMaterialTextureCount(long pMat, int type)
      unsigned int aiGetMaterialTextureCount(struct aiMaterial const * pMat, aiTextureType type)

    • aiGetMaterialTextureCount

      public static int aiGetMaterialTextureCount(AIMaterial pMat, int type)
      unsigned int aiGetMaterialTextureCount(struct aiMaterial const * pMat, aiTextureType type)

    • naiGetMaterialTexture

      public static int naiGetMaterialTexture(long pMat, int type, int index, long path, long mapping, long uvindex, long blend, long op, long mapmode, long flags)
      aiReturn aiGetMaterialTexture(struct aiMaterial const * pMat, aiTextureType type, unsigned int index, struct aiString * path, aiTextureMapping * mapping, unsigned int * uvindex, float * blend, aiTextureOp * op, aiTextureMapMode * mapmode, unsigned int * flags)

    • aiGetMaterialTexture

      public static int aiGetMaterialTexture(AIMaterial pMat, int type, int index, AIString path, @Nullable IntBuffer mapping, @Nullable IntBuffer uvindex, @Nullable FloatBuffer blend, @Nullable IntBuffer op, @Nullable IntBuffer mapmode, @Nullable IntBuffer flags)
      aiReturn aiGetMaterialTexture(struct aiMaterial const * pMat, aiTextureType type, unsigned int index, struct aiString * path, aiTextureMapping * mapping, unsigned int * uvindex, float * blend, aiTextureOp * op, aiTextureMapMode * mapmode, unsigned int * flags)

    • naiGetLegalString

      public static long naiGetLegalString()
      char const * aiGetLegalString(void)

    • aiGetLegalString

      public static String aiGetLegalString()
      char const * aiGetLegalString(void)

    • aiGetVersionPatch

      public static int aiGetVersionPatch()
      unsigned int aiGetVersionPatch(void)

    • aiGetVersionMinor

      public static int aiGetVersionMinor()
      unsigned int aiGetVersionMinor(void)

    • aiGetVersionMajor

      public static int aiGetVersionMajor()
      unsigned int aiGetVersionMajor(void)

    • aiGetVersionRevision

      public static int aiGetVersionRevision()
      unsigned int aiGetVersionRevision(void)

    • naiGetBranchName

      public static long naiGetBranchName()
      char const * aiGetBranchName(void)

    • aiGetBranchName

      public static @Nullable String aiGetBranchName()
      char const * aiGetBranchName(void)

    • aiGetCompileFlags

      public static int aiGetCompileFlags()
      unsigned int aiGetCompileFlags(void)

    • aiMatrix4DecomposeIntoScalingAxisAnglePosition

      public static void aiMatrix4DecomposeIntoScalingAxisAnglePosition(AIMatrix4x4 mat, AIVector3D scaling, AIVector3D axis, float[] angle, AIVector3D position)
      void aiMatrix4DecomposeIntoScalingAxisAnglePosition(struct aiMatrix4x4 const * mat, struct aiVector3D * scaling, struct aiVector3D * axis, ai_real * angle, struct aiVector3D * position)

    • aiGetMaterialFloatArray

      public static int aiGetMaterialFloatArray(AIMaterial pMat, ByteBuffer pKey, int type, int index, float[] pOut, int @Nullable [] pMax)
      aiReturn aiGetMaterialFloatArray(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, ai_real * pOut, unsigned int * pMax)

    • aiGetMaterialFloatArray

      public static int aiGetMaterialFloatArray(AIMaterial pMat, CharSequence pKey, int type, int index, float[] pOut, int @Nullable [] pMax)
      aiReturn aiGetMaterialFloatArray(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, ai_real * pOut, unsigned int * pMax)

    • aiGetMaterialIntegerArray

      public static int aiGetMaterialIntegerArray(AIMaterial pMat, ByteBuffer pKey, int type, int index, int[] pOut, int @Nullable [] pMax)
      aiReturn aiGetMaterialIntegerArray(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, int * pOut, unsigned int * pMax)

    • aiGetMaterialIntegerArray

      public static int aiGetMaterialIntegerArray(AIMaterial pMat, CharSequence pKey, int type, int index, int[] pOut, int @Nullable [] pMax)
      aiReturn aiGetMaterialIntegerArray(struct aiMaterial const * pMat, char const * pKey, unsigned int type, unsigned int index, int * pOut, unsigned int * pMax)

    • aiGetMaterialTexture

      public static int aiGetMaterialTexture(AIMaterial pMat, int type, int index, AIString path, int @Nullable [] mapping, int @Nullable [] uvindex, float @Nullable [] blend, int @Nullable [] op, int @Nullable [] mapmode, int @Nullable [] flags)
      aiReturn aiGetMaterialTexture(struct aiMaterial const * pMat, aiTextureType type, unsigned int index, struct aiString * path, aiTextureMapping * mapping, unsigned int * uvindex, float * blend, aiTextureOp * op, aiTextureMapMode * mapmode, unsigned int * flags)