v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

commit new try of c# bindings 

git-svn-id: https://assimp.svn.sourceforge.net/svnroot/assimp/trunk@741 67173fc5-114c-0410-ac8e-9d2fd5bffc1f
pull/1/head
rave3d 2010-05-27 18:28:02 +00:00
parent c96b831be5
commit d91f661082
122 changed files with 10339 additions and 4856 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
port/Assimp.NET/Assimp.NET.sln
View File

@ -8,6 +8,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Assimp.NET_CS", "Assimp.NET
{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E} = {A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}
EndProjectSection
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Assimp.NET_DEMO", "Assimp.NET_DEMO\Assimp.NET_DEMO.csproj", "{B2813591-1491-4C99-B6E2-67B484411AFC}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
@ -38,6 +40,16 @@ Global
{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{A0CE9ED2-A27E-40AE-95F5-FEF94BB7E131}.Release|Win32.ActiveCfg = Release|Any CPU
{B2813591-1491-4C99-B6E2-67B484411AFC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{B2813591-1491-4C99-B6E2-67B484411AFC}.Debug|Any CPU.Build.0 = Debug|Any CPU
{B2813591-1491-4C99-B6E2-67B484411AFC}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{B2813591-1491-4C99-B6E2-67B484411AFC}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{B2813591-1491-4C99-B6E2-67B484411AFC}.Debug|Win32.ActiveCfg = Debug|Any CPU
{B2813591-1491-4C99-B6E2-67B484411AFC}.Release|Any CPU.ActiveCfg = Release|Any CPU
{B2813591-1491-4C99-B6E2-67B484411AFC}.Release|Any CPU.Build.0 = Release|Any CPU
{B2813591-1491-4C99-B6E2-67B484411AFC}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{B2813591-1491-4C99-B6E2-67B484411AFC}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{B2813591-1491-4C99-B6E2-67B484411AFC}.Release|Win32.ActiveCfg = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

15
port/Assimp.NET/Assimp.NET/Assimp.NET.vcproj
View File

@ -2,7 +2,7 @@
<VisualStudioProject
ProjectType="Visual C++"
Version="9,00"
Name="Assimp.NET"
Name="Assimp_NET"
ProjectGUID="{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}"
RootNamespace="AssimpNET"
Keyword="ManagedCProj"
@ -30,7 +30,7 @@
/>
<Tool
Name="VCCustomBuildTool"
CommandLine="move *.cs ..\Assimp.NET_CS\&#x0D;&#x0A;"
CommandLine=""
/>
<Tool
Name="VCXMLDataGeneratorTool"
@ -46,8 +46,9 @@
Optimization="0"
PreprocessorDefinitions="WIN32;_DEBUG"
RuntimeLibrary="3"
EnableFunctionLevelLinking="true"
UsePrecompiledHeader="0"
WarningLevel="3"
WarningLevel="4"
DebugInformationFormat="3"
/>
<Tool
@ -62,11 +63,17 @@
<Tool
Name="VCLinkerTool"
AdditionalDependencies="assimp.lib"
OutputFile="$(OutDir)\Assimp_NET.dll"
LinkIncremental="2"
AdditionalLibraryDirectories="..\..\..\lib\assimp_$(ConfigurationName)_$(PlatformName)"
AdditionalLibraryDirectories="&quot;D:\Projekte\Assimp\trunk\lib\assimp_debug-dll_Win32&quot;"
EnableUAC="false"
AddModuleNamesToAssembly=""
GenerateDebugInformation="true"
AssemblyDebug="1"
SubSystem="2"
TargetMachine="1"
CLRThreadAttribute="1"
CLRUnmanagedCodeCheck="false"
/>
<Tool
Name="VCALinkTool"

6
port/Assimp.NET/Assimp.NET/AssimpSwigPort.i
View File

@ -1,5 +1,5 @@
/* File : example.i */
%module Assimp
%module Assimp_NET
%{
//#include "..\..\..\include\aiAssert.h"
#include "..\..\..\include\aiDefines.h"
@ -55,6 +55,10 @@
%rename(opDelete) operator delete;
%rename(opDeleteArray) operator delete[];
%rename(ReadFile_s) ReadFile(std::string const &,unsigned int);
//%rename(ReadFile_c) ReadFile(char const *,unsigned int);
//%rename(Node) aiNode;

37
port/Assimp.NET/Assimp.NET_CS/Assimp.NET_CS.csproj
View File

@ -44,28 +44,47 @@
<Reference Include="System.Data" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Assimp.NET\Assimp.NET.vcproj">
<Project>{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}</Project>
<Name>Assimp_NET</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<Compile Include="aiAnimation.cs" />
<Compile Include="aiAnimationVector.cs" />
<Compile Include="aiAnimBehaviour.cs" />
<Compile Include="aiAnimMesh.cs" />
<Compile Include="aiBlendMode.cs" />
<Compile Include="aiBone.cs" />
<Compile Include="aiCamera.cs" />
<Compile Include="aiCameraVector.cs" />
<Compile Include="aiColor3D.cs" />
<Compile Include="aiColor4DVector.cs" />
<Compile Include="aiColor4DVectorVector.cs" />
<Compile Include="aiComponent.cs" />
<Compile Include="aiDefaultLogStream.cs" />
<Compile Include="aiFace.cs" />
<Compile Include="aiFaceVector.cs" />
<Compile Include="aiFile.cs" />
<Compile Include="aiFileIO.cs" />
<Compile Include="aiLight.cs" />
<Compile Include="aiLightSourceType.cs" />
<Compile Include="aiLightVector.cs" />
<Compile Include="aiMaterial.cs" />
<Compile Include="aiMaterialProperty.cs" />
<Compile Include="aiMaterialVector.cs" />
<Compile Include="aiMatrix3x3.cs" />
<Compile Include="aiMatrix4x4.cs" />
<Compile Include="aiMemoryInfo.cs" />
<Compile Include="aiMesh.cs" />
<Compile Include="aiMeshAnim.cs" />
<Compile Include="aiMeshKey.cs" />
<Compile Include="aiMeshVector.cs" />
<Compile Include="aiNode.cs" />
<Compile Include="aiNodeAnim.cs" />
<Compile Include="aiNodeAnimVector.cs" />
<Compile Include="aiNodeVector.cs" />
<Compile Include="aiOrigin.cs" />
<Compile Include="aiPlane.cs" />
<Compile Include="aiPostProcessSteps.cs" />
@ -85,21 +104,22 @@
<Compile Include="aiTextureMapping.cs" />
<Compile Include="aiTextureOp.cs" />
<Compile Include="aiTextureType.cs" />
<Compile Include="aiTextureVector.cs" />
<Compile Include="aiUVTransform.cs" />
<Compile Include="aiVector2D.cs" />
<Compile Include="aiVector3D.cs" />
<Compile Include="aiVector3DVector.cs" />
<Compile Include="aiVector3DVectorVector.cs" />
<Compile Include="aiVectorKey.cs" />
<Compile Include="aiVertexWeight.cs" />
<Compile Include="AllocateFromAssimpHeap.cs" />
<Compile Include="Assimp.cs" />
<Compile Include="AssimpPINVOKE.cs" />
<Compile Include="Assimp_NET.cs" />
<Compile Include="Assimp_NETPINVOKE.cs" />
<Compile Include="Importer.cs" />
<Compile Include="IOStream.cs" />
<Compile Include="IOSystem.cs" />
<Compile Include="Logger.cs" />
<Compile Include="LogStream.cs" />
<Compile Include="NullLogger.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="SWIGTYPE_p_aiColor4D.cs" />
<Compile Include="SWIGTYPE_p_aiTextureMapMode.cs" />
<Compile Include="SWIGTYPE_p_aiTextureMapping.cs" />
@ -117,6 +137,7 @@
<Compile Include="SWIGTYPE_p_f_p_aiFile__void.cs" />
<Compile Include="SWIGTYPE_p_int.cs" />
<Compile Include="SWIGTYPE_p_p_aiAnimation.cs" />
<Compile Include="SWIGTYPE_p_p_aiAnimMesh.cs" />
<Compile Include="SWIGTYPE_p_p_aiBone.cs" />
<Compile Include="SWIGTYPE_p_p_aiCamera.cs" />
<Compile Include="SWIGTYPE_p_p_aiColor4D.cs" />
@ -124,20 +145,18 @@
<Compile Include="SWIGTYPE_p_p_aiMaterial.cs" />
<Compile Include="SWIGTYPE_p_p_aiMaterialProperty.cs" />
<Compile Include="SWIGTYPE_p_p_aiMesh.cs" />
<Compile Include="SWIGTYPE_p_p_aiMeshAnim.cs" />
<Compile Include="SWIGTYPE_p_p_aiNode.cs" />
<Compile Include="SWIGTYPE_p_p_aiNodeAnim.cs" />
<Compile Include="SWIGTYPE_p_p_aiTexture.cs" />
<Compile Include="SWIGTYPE_p_p_aiVector3D.cs" />
<Compile Include="SWIGTYPE_p_std__nothrow_t.cs" />
<Compile Include="SWIGTYPE_p_std__string.cs" />
<Compile Include="SWIGTYPE_p_unsigned_int.cs" />
<Compile Include="SWIGTYPE_p_void.cs" />
<Compile Include="UintVector.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Assimp.NET\Assimp.NET.vcproj">
<Project>{A86A8AF2-3B4D-4381-BB01-9CA2AE88450E}</Project>
<Name>Assimp.NET</Name>
</ProjectReference>
<Folder Include="Properties\" />
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.

199
port/Assimp.NET/Assimp.NET_CS/Assimp_NET.cs 100644
View File

@ -0,0 +1,199 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class Assimp_NET {
public static uint MAXLEN {
get {
uint ret = Assimp_NETPINVOKE.MAXLEN_get();
return ret;
}
}
public static aiVector2D __add__(aiVector2D v1, aiVector2D v2) {
aiVector2D ret = new aiVector2D(Assimp_NETPINVOKE.__add__(aiVector2D.getCPtr(v1), aiVector2D.getCPtr(v2)), true);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static aiVector2D __sub__(aiVector2D v1, aiVector2D v2) {
aiVector2D ret = new aiVector2D(Assimp_NETPINVOKE.__sub____SWIG_0(aiVector2D.getCPtr(v1), aiVector2D.getCPtr(v2)), true);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static float __mul__(aiVector2D v1, aiVector2D v2) {
float ret = Assimp_NETPINVOKE.__mul____SWIG_0(aiVector2D.getCPtr(v1), aiVector2D.getCPtr(v2));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static aiVector2D __mul__(float f, aiVector2D v) {
aiVector2D ret = new aiVector2D(Assimp_NETPINVOKE.__mul____SWIG_1(f, aiVector2D.getCPtr(v)), true);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static aiVector2D __mul__(aiVector2D v, float f) {
aiVector2D ret = new aiVector2D(Assimp_NETPINVOKE.__mul____SWIG_2(aiVector2D.getCPtr(v), f), true);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static aiVector2D __div__(aiVector2D v, float f) {
aiVector2D ret = new aiVector2D(Assimp_NETPINVOKE.__div____SWIG_0(aiVector2D.getCPtr(v), f), true);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static aiVector2D __div__(aiVector2D v, aiVector2D v2) {
aiVector2D ret = new aiVector2D(Assimp_NETPINVOKE.__div____SWIG_1(aiVector2D.getCPtr(v), aiVector2D.getCPtr(v2)), true);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static aiVector2D __sub__(aiVector2D v) {
aiVector2D ret = new aiVector2D(Assimp_NETPINVOKE.__sub____SWIG_1(aiVector2D.getCPtr(v)), true);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static aiReturn aiGetMaterialProperty(aiMaterial pMat, string pKey, uint type, uint index, SWIGTYPE_p_p_aiMaterialProperty pPropOut) {
aiReturn ret = (aiReturn)Assimp_NETPINVOKE.aiGetMaterialProperty(aiMaterial.getCPtr(pMat), pKey, type, index, SWIGTYPE_p_p_aiMaterialProperty.getCPtr(pPropOut));
return ret;
}
public static aiReturn aiGetMaterialFloatArray(aiMaterial pMat, string pKey, uint type, uint index, SWIGTYPE_p_float pOut, SWIGTYPE_p_unsigned_int pMax) {
aiReturn ret = (aiReturn)Assimp_NETPINVOKE.aiGetMaterialFloatArray(aiMaterial.getCPtr(pMat), pKey, type, index, SWIGTYPE_p_float.getCPtr(pOut), SWIGTYPE_p_unsigned_int.getCPtr(pMax));
return ret;
}
public static aiReturn aiGetMaterialFloat(aiMaterial pMat, string pKey, uint type, uint index, SWIGTYPE_p_float pOut) {
aiReturn ret = (aiReturn)Assimp_NETPINVOKE.aiGetMaterialFloat(aiMaterial.getCPtr(pMat), pKey, type, index, SWIGTYPE_p_float.getCPtr(pOut));
return ret;
}
public static aiReturn aiGetMaterialIntegerArray(aiMaterial pMat, string pKey, uint type, uint index, SWIGTYPE_p_int pOut, SWIGTYPE_p_unsigned_int pMax) {
aiReturn ret = (aiReturn)Assimp_NETPINVOKE.aiGetMaterialIntegerArray(aiMaterial.getCPtr(pMat), pKey, type, index, SWIGTYPE_p_int.getCPtr(pOut), SWIGTYPE_p_unsigned_int.getCPtr(pMax));
return ret;
}
public static aiReturn aiGetMaterialInteger(aiMaterial pMat, string pKey, uint type, uint index, SWIGTYPE_p_int pOut) {
aiReturn ret = (aiReturn)Assimp_NETPINVOKE.aiGetMaterialInteger(aiMaterial.getCPtr(pMat), pKey, type, index, SWIGTYPE_p_int.getCPtr(pOut));
return ret;
}
public static aiReturn aiGetMaterialColor(aiMaterial pMat, string pKey, uint type, uint index, SWIGTYPE_p_aiColor4D pOut) {
aiReturn ret = (aiReturn)Assimp_NETPINVOKE.aiGetMaterialColor(aiMaterial.getCPtr(pMat), pKey, type, index, SWIGTYPE_p_aiColor4D.getCPtr(pOut));
return ret;
}
public static aiReturn aiGetMaterialString(aiMaterial pMat, string pKey, uint type, uint index, aiString pOut) {
aiReturn ret = (aiReturn)Assimp_NETPINVOKE.aiGetMaterialString(aiMaterial.getCPtr(pMat), pKey, type, index, aiString.getCPtr(pOut));
return ret;
}
public static uint aiGetMaterialTextureCount(aiMaterial pMat, aiTextureType type) {
uint ret = Assimp_NETPINVOKE.aiGetMaterialTextureCount(aiMaterial.getCPtr(pMat), (int)type);
return ret;
}
public static aiReturn aiGetMaterialTexture(aiMaterial mat, aiTextureType type, uint index, aiString path, SWIGTYPE_p_aiTextureMapping mapping, SWIGTYPE_p_unsigned_int uvindex, SWIGTYPE_p_float blend, SWIGTYPE_p_aiTextureOp op, SWIGTYPE_p_aiTextureMapMode mapmode, SWIGTYPE_p_unsigned_int flags) {
aiReturn ret = (aiReturn)Assimp_NETPINVOKE.aiGetMaterialTexture(aiMaterial.getCPtr(mat), (int)type, index, aiString.getCPtr(path), SWIGTYPE_p_aiTextureMapping.getCPtr(mapping), SWIGTYPE_p_unsigned_int.getCPtr(uvindex), SWIGTYPE_p_float.getCPtr(blend), SWIGTYPE_p_aiTextureOp.getCPtr(op), SWIGTYPE_p_aiTextureMapMode.getCPtr(mapmode), SWIGTYPE_p_unsigned_int.getCPtr(flags));
return ret;
}
public static aiScene aiImportFileEx(string arg0, uint arg1, aiFileIO arg2) {
IntPtr cPtr = Assimp_NETPINVOKE.aiImportFileEx(arg0, arg1, aiFileIO.getCPtr(arg2));
aiScene ret = (cPtr == IntPtr.Zero) ? null : new aiScene(cPtr, false);
return ret;
}
public static aiScene aiImportFileFromMemory(string arg0, uint arg1, uint arg2, string arg3) {
IntPtr cPtr = Assimp_NETPINVOKE.aiImportFileFromMemory(arg0, arg1, arg2, arg3);
aiScene ret = (cPtr == IntPtr.Zero) ? null : new aiScene(cPtr, false);
return ret;
}
public static readonly double AI_MATH_PI = Assimp_NETPINVOKE.AI_MATH_PI_get();
public static readonly double AI_MATH_TWO_PI = Assimp_NETPINVOKE.AI_MATH_TWO_PI_get();
public static readonly double AI_MATH_HALF_PI = Assimp_NETPINVOKE.AI_MATH_HALF_PI_get();
public static readonly double AI_MATH_PI_F = Assimp_NETPINVOKE.AI_MATH_PI_F_get();
public static readonly double AI_MATH_TWO_PI_F = Assimp_NETPINVOKE.AI_MATH_TWO_PI_F_get();
public static readonly double AI_MATH_HALF_PI_F = Assimp_NETPINVOKE.AI_MATH_HALF_PI_F_get();
public static readonly string AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE = Assimp_NETPINVOKE.AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE_get();
public static readonly string AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE = Assimp_NETPINVOKE.AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE_get();
public static readonly string AI_CONFIG_IMPORT_MDL_COLORMAP = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_MDL_COLORMAP_get();
public static readonly string AI_CONFIG_PP_RRM_EXCLUDE_LIST = Assimp_NETPINVOKE.AI_CONFIG_PP_RRM_EXCLUDE_LIST_get();
public static readonly string AI_CONFIG_PP_PTV_KEEP_HIERARCHY = Assimp_NETPINVOKE.AI_CONFIG_PP_PTV_KEEP_HIERARCHY_get();
public static readonly string AI_CONFIG_PP_PTV_NORMALIZE = Assimp_NETPINVOKE.AI_CONFIG_PP_PTV_NORMALIZE_get();
public static readonly string AI_CONFIG_PP_FD_REMOVE = Assimp_NETPINVOKE.AI_CONFIG_PP_FD_REMOVE_get();
public static readonly string AI_CONFIG_PP_OG_EXCLUDE_LIST = Assimp_NETPINVOKE.AI_CONFIG_PP_OG_EXCLUDE_LIST_get();
public static readonly string AI_CONFIG_PP_SLM_TRIANGLE_LIMIT = Assimp_NETPINVOKE.AI_CONFIG_PP_SLM_TRIANGLE_LIMIT_get();
public static readonly int AI_SLM_DEFAULT_MAX_TRIANGLES = Assimp_NETPINVOKE.AI_SLM_DEFAULT_MAX_TRIANGLES_get();
public static readonly string AI_CONFIG_PP_SLM_VERTEX_LIMIT = Assimp_NETPINVOKE.AI_CONFIG_PP_SLM_VERTEX_LIMIT_get();
public static readonly int AI_SLM_DEFAULT_MAX_VERTICES = Assimp_NETPINVOKE.AI_SLM_DEFAULT_MAX_VERTICES_get();
public static readonly string AI_CONFIG_PP_LBW_MAX_WEIGHTS = Assimp_NETPINVOKE.AI_CONFIG_PP_LBW_MAX_WEIGHTS_get();
public static readonly int AI_LMW_MAX_WEIGHTS = Assimp_NETPINVOKE.AI_LMW_MAX_WEIGHTS_get();
public static readonly int PP_ICL_PTCACHE_SIZE = Assimp_NETPINVOKE.PP_ICL_PTCACHE_SIZE_get();
public static readonly string AI_CONFIG_PP_ICL_PTCACHE_SIZE = Assimp_NETPINVOKE.AI_CONFIG_PP_ICL_PTCACHE_SIZE_get();
public static readonly string AI_CONFIG_PP_RVC_FLAGS = Assimp_NETPINVOKE.AI_CONFIG_PP_RVC_FLAGS_get();
public static readonly string AI_CONFIG_PP_SBP_REMOVE = Assimp_NETPINVOKE.AI_CONFIG_PP_SBP_REMOVE_get();
public static readonly string AI_CONFIG_PP_FID_ANIM_ACCURACY = Assimp_NETPINVOKE.AI_CONFIG_PP_FID_ANIM_ACCURACY_get();
public static readonly int AI_UVTRAFO_SCALING = Assimp_NETPINVOKE.AI_UVTRAFO_SCALING_get();
public static readonly int AI_UVTRAFO_ROTATION = Assimp_NETPINVOKE.AI_UVTRAFO_ROTATION_get();
public static readonly int AI_UVTRAFO_TRANSLATION = Assimp_NETPINVOKE.AI_UVTRAFO_TRANSLATION_get();
public static readonly int AI_UVTRAFO_ALL = Assimp_NETPINVOKE.AI_UVTRAFO_ALL_get();
public static readonly string AI_CONFIG_PP_TUV_EVALUATE = Assimp_NETPINVOKE.AI_CONFIG_PP_TUV_EVALUATE_get();
public static readonly string AI_CONFIG_FAVOUR_SPEED = Assimp_NETPINVOKE.AI_CONFIG_FAVOUR_SPEED_get();
public static readonly string AI_CONFIG_IMPORT_GLOBAL_KEYFRAME = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_GLOBAL_KEYFRAME_get();
public static readonly string AI_CONFIG_IMPORT_MD3_KEYFRAME = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_MD3_KEYFRAME_get();
public static readonly string AI_CONFIG_IMPORT_MD2_KEYFRAME = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_MD2_KEYFRAME_get();
public static readonly string AI_CONFIG_IMPORT_MDL_KEYFRAME = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_MDL_KEYFRAME_get();
public static readonly string AI_CONFIG_IMPORT_MDC_KEYFRAME = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_MDC_KEYFRAME_get();
public static readonly string AI_CONFIG_IMPORT_SMD_KEYFRAME = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_SMD_KEYFRAME_get();
public static readonly string AI_CONFIG_IMPORT_UNREAL_KEYFRAME = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_UNREAL_KEYFRAME_get();
public static readonly string AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL_get();
public static readonly string AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION_get();
public static readonly string AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS_get();
public static readonly string AI_CONFIG_IMPORT_TER_MAKE_UVS = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_TER_MAKE_UVS_get();
public static readonly string AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS_get();
public static readonly string AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART_get();
public static readonly string AI_CONFIG_IMPORT_MD3_SKIN_NAME = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_MD3_SKIN_NAME_get();
public static readonly string AI_CONFIG_IMPORT_MD3_SHADER_SRC = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_MD3_SHADER_SRC_get();
public static readonly string AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY_get();
public static readonly string AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD_get();
public static readonly string AI_CONFIG_IMPORT_LWS_ANIM_START = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_LWS_ANIM_START_get();
public static readonly string AI_CONFIG_IMPORT_LWS_ANIM_END = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_LWS_ANIM_END_get();
public static readonly string AI_CONFIG_IMPORT_IRR_ANIM_FPS = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_IRR_ANIM_FPS_get();
public static readonly string AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE = Assimp_NETPINVOKE.AI_CONFIG_IMPORT_OGRE_MATERIAL_FILE_get();
public static readonly int AI_MAX_NUMBER_OF_COLOR_SETS = Assimp_NETPINVOKE.AI_MAX_NUMBER_OF_COLOR_SETS_get();
public static readonly int AI_MAX_NUMBER_OF_TEXTURECOORDS = Assimp_NETPINVOKE.AI_MAX_NUMBER_OF_TEXTURECOORDS_get();
public static readonly string AI_DEFAULT_MATERIAL_NAME = Assimp_NETPINVOKE.AI_DEFAULT_MATERIAL_NAME_get();
public static readonly string AI_DEFAULT_TEXTURED_MATERIAL_NAME = Assimp_NETPINVOKE.AI_DEFAULT_TEXTURED_MATERIAL_NAME_get();
public static readonly string _AI_MATKEY_TEXTURE_BASE = Assimp_NETPINVOKE._AI_MATKEY_TEXTURE_BASE_get();
public static readonly string _AI_MATKEY_UVWSRC_BASE = Assimp_NETPINVOKE._AI_MATKEY_UVWSRC_BASE_get();
public static readonly string _AI_MATKEY_TEXOP_BASE = Assimp_NETPINVOKE._AI_MATKEY_TEXOP_BASE_get();
public static readonly string _AI_MATKEY_MAPPING_BASE = Assimp_NETPINVOKE._AI_MATKEY_MAPPING_BASE_get();
public static readonly string _AI_MATKEY_TEXBLEND_BASE = Assimp_NETPINVOKE._AI_MATKEY_TEXBLEND_BASE_get();
public static readonly string _AI_MATKEY_MAPPINGMODE_U_BASE = Assimp_NETPINVOKE._AI_MATKEY_MAPPINGMODE_U_BASE_get();
public static readonly string _AI_MATKEY_MAPPINGMODE_V_BASE = Assimp_NETPINVOKE._AI_MATKEY_MAPPINGMODE_V_BASE_get();
public static readonly string _AI_MATKEY_TEXMAP_AXIS_BASE = Assimp_NETPINVOKE._AI_MATKEY_TEXMAP_AXIS_BASE_get();
public static readonly string _AI_MATKEY_UVTRANSFORM_BASE = Assimp_NETPINVOKE._AI_MATKEY_UVTRANSFORM_BASE_get();
public static readonly string _AI_MATKEY_TEXFLAGS_BASE = Assimp_NETPINVOKE._AI_MATKEY_TEXFLAGS_BASE_get();
public static readonly int AI_SCENE_FLAGS_INCOMPLETE = Assimp_NETPINVOKE.AI_SCENE_FLAGS_INCOMPLETE_get();
public static readonly int AI_SCENE_FLAGS_VALIDATED = Assimp_NETPINVOKE.AI_SCENE_FLAGS_VALIDATED_get();
public static readonly int AI_SCENE_FLAGS_VALIDATION_WARNING = Assimp_NETPINVOKE.AI_SCENE_FLAGS_VALIDATION_WARNING_get();
public static readonly int AI_SCENE_FLAGS_NON_VERBOSE_FORMAT = Assimp_NETPINVOKE.AI_SCENE_FLAGS_NON_VERBOSE_FORMAT_get();
public static readonly int AI_SCENE_FLAGS_TERRAIN = Assimp_NETPINVOKE.AI_SCENE_FLAGS_TERRAIN_get();
public static readonly int AI_PROPERTY_WAS_NOT_EXISTING = Assimp_NETPINVOKE.AI_PROPERTY_WAS_NOT_EXISTING_get();
public static readonly uint MAX_LOG_MESSAGE_LENGTH = Assimp_NETPINVOKE.MAX_LOG_MESSAGE_LENGTH_get();
}

3513
port/Assimp.NET/Assimp.NET_CS/Assimp_NETPINVOKE.cs 100644
View File

File diff suppressed because it is too large Load Diff

72
port/Assimp.NET/Assimp.NET_CS/IOStream.cs 100644
View File

@ -0,0 +1,72 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class IOStream : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal IOStream(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(IOStream obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~IOStream() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_IOStream(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public virtual uint Read(SWIGTYPE_p_void pvBuffer, uint pSize, uint pCount) {
uint ret = Assimp_NETPINVOKE.IOStream_Read(swigCPtr, SWIGTYPE_p_void.getCPtr(pvBuffer), pSize, pCount);
return ret;
}
public virtual uint Write(SWIGTYPE_p_void pvBuffer, uint pSize, uint pCount) {
uint ret = Assimp_NETPINVOKE.IOStream_Write(swigCPtr, SWIGTYPE_p_void.getCPtr(pvBuffer), pSize, pCount);
return ret;
}
public virtual aiReturn Seek(uint pOffset, aiOrigin pOrigin) {
aiReturn ret = (aiReturn)Assimp_NETPINVOKE.IOStream_Seek(swigCPtr, pOffset, (int)pOrigin);
return ret;
}
public virtual uint Tell() {
uint ret = Assimp_NETPINVOKE.IOStream_Tell(swigCPtr);
return ret;
}
public virtual uint FileSize() {
uint ret = Assimp_NETPINVOKE.IOStream_FileSize(swigCPtr);
return ret;
}
public virtual void Flush() {
Assimp_NETPINVOKE.IOStream_Flush(swigCPtr);
}
}

75
port/Assimp.NET/Assimp.NET_CS/IOSystem.cs 100644
View File

@ -0,0 +1,75 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class IOSystem : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal IOSystem(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(IOSystem obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~IOSystem() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_IOSystem(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public bool Exists(string pFile) {
bool ret = Assimp_NETPINVOKE.IOSystem_Exists__SWIG_0(swigCPtr, pFile);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public virtual char getOsSeparator() {
char ret = Assimp_NETPINVOKE.IOSystem_getOsSeparator(swigCPtr);
return ret;
}
public virtual IOStream Open(string pFile, string pMode) {
IntPtr cPtr = Assimp_NETPINVOKE.IOSystem_Open__SWIG_0(swigCPtr, pFile, pMode);
IOStream ret = (cPtr == IntPtr.Zero) ? null : new IOStream(cPtr, false);
return ret;
}
public virtual IOStream Open(string pFile) {
IntPtr cPtr = Assimp_NETPINVOKE.IOSystem_Open__SWIG_1(swigCPtr, pFile);
IOStream ret = (cPtr == IntPtr.Zero) ? null : new IOStream(cPtr, false);
return ret;
}
public virtual void Close(IOStream pFile) {
Assimp_NETPINVOKE.IOSystem_Close(swigCPtr, IOStream.getCPtr(pFile));
}
public virtual bool ComparePaths(string one, string second) {
bool ret = Assimp_NETPINVOKE.IOSystem_ComparePaths__SWIG_0(swigCPtr, one, second);
return ret;
}
}

229
port/Assimp.NET/Assimp.NET_CS/Importer.cs 100644
View File

@ -0,0 +1,229 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class Importer : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal Importer(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(Importer obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~Importer() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_Importer(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public Importer() : this(Assimp_NETPINVOKE.new_Importer__SWIG_0(), true) {
}
public Importer(Importer other) : this(Assimp_NETPINVOKE.new_Importer__SWIG_1(Importer.getCPtr(other)), true) {
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public aiReturn RegisterLoader(SWIGTYPE_p_Assimp__BaseImporter pImp) {
aiReturn ret = (aiReturn)Assimp_NETPINVOKE.Importer_RegisterLoader(swigCPtr, SWIGTYPE_p_Assimp__BaseImporter.getCPtr(pImp));
return ret;
}
public aiReturn UnregisterLoader(SWIGTYPE_p_Assimp__BaseImporter pImp) {
aiReturn ret = (aiReturn)Assimp_NETPINVOKE.Importer_UnregisterLoader(swigCPtr, SWIGTYPE_p_Assimp__BaseImporter.getCPtr(pImp));
return ret;
}
public aiReturn RegisterPPStep(SWIGTYPE_p_Assimp__BaseProcess pImp) {
aiReturn ret = (aiReturn)Assimp_NETPINVOKE.Importer_RegisterPPStep(swigCPtr, SWIGTYPE_p_Assimp__BaseProcess.getCPtr(pImp));
return ret;
}
public aiReturn UnregisterPPStep(SWIGTYPE_p_Assimp__BaseProcess pImp) {
aiReturn ret = (aiReturn)Assimp_NETPINVOKE.Importer_UnregisterPPStep(swigCPtr, SWIGTYPE_p_Assimp__BaseProcess.getCPtr(pImp));
return ret;
}
public void SetPropertyInteger(string szName, int iValue, SWIGTYPE_p_bool bWasExisting) {
Assimp_NETPINVOKE.Importer_SetPropertyInteger__SWIG_0(swigCPtr, szName, iValue, SWIGTYPE_p_bool.getCPtr(bWasExisting));
}
public void SetPropertyInteger(string szName, int iValue) {
Assimp_NETPINVOKE.Importer_SetPropertyInteger__SWIG_1(swigCPtr, szName, iValue);
}
public void SetPropertyFloat(string szName, float fValue, SWIGTYPE_p_bool bWasExisting) {
Assimp_NETPINVOKE.Importer_SetPropertyFloat__SWIG_0(swigCPtr, szName, fValue, SWIGTYPE_p_bool.getCPtr(bWasExisting));
}
public void SetPropertyFloat(string szName, float fValue) {
Assimp_NETPINVOKE.Importer_SetPropertyFloat__SWIG_1(swigCPtr, szName, fValue);
}
public void SetPropertyString(string szName, string sValue, SWIGTYPE_p_bool bWasExisting) {
Assimp_NETPINVOKE.Importer_SetPropertyString__SWIG_0(swigCPtr, szName, sValue, SWIGTYPE_p_bool.getCPtr(bWasExisting));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public void SetPropertyString(string szName, string sValue) {
Assimp_NETPINVOKE.Importer_SetPropertyString__SWIG_1(swigCPtr, szName, sValue);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public int GetPropertyInteger(string szName, int iErrorReturn) {
int ret = Assimp_NETPINVOKE.Importer_GetPropertyInteger__SWIG_0(swigCPtr, szName, iErrorReturn);
return ret;
}
public int GetPropertyInteger(string szName) {
int ret = Assimp_NETPINVOKE.Importer_GetPropertyInteger__SWIG_1(swigCPtr, szName);
return ret;
}
public float GetPropertyFloat(string szName, float fErrorReturn) {
float ret = Assimp_NETPINVOKE.Importer_GetPropertyFloat__SWIG_0(swigCPtr, szName, fErrorReturn);
return ret;
}
public float GetPropertyFloat(string szName) {
float ret = Assimp_NETPINVOKE.Importer_GetPropertyFloat__SWIG_1(swigCPtr, szName);
return ret;
}
public string GetPropertyString(string szName, string sErrorReturn) {
string ret = Assimp_NETPINVOKE.Importer_GetPropertyString__SWIG_0(swigCPtr, szName, sErrorReturn);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public string GetPropertyString(string szName) {
string ret = Assimp_NETPINVOKE.Importer_GetPropertyString__SWIG_1(swigCPtr, szName);
return ret;
}
public void SetIOHandler(IOSystem pIOHandler) {
Assimp_NETPINVOKE.Importer_SetIOHandler(swigCPtr, IOSystem.getCPtr(pIOHandler));
}
public IOSystem GetIOHandler() {
IntPtr cPtr = Assimp_NETPINVOKE.Importer_GetIOHandler(swigCPtr);
IOSystem ret = (cPtr == IntPtr.Zero) ? null : new IOSystem(cPtr, false);
return ret;
}
public bool IsDefaultIOHandler() {
bool ret = Assimp_NETPINVOKE.Importer_IsDefaultIOHandler(swigCPtr);
return ret;
}
public bool ValidateFlags(uint pFlags) {
bool ret = Assimp_NETPINVOKE.Importer_ValidateFlags(swigCPtr, pFlags);
return ret;
}
public aiScene ReadFile(string pFile, uint pFlags) {
IntPtr cPtr = Assimp_NETPINVOKE.Importer_ReadFile(swigCPtr, pFile, pFlags);
aiScene ret = (cPtr == IntPtr.Zero) ? null : new aiScene(cPtr, false);
return ret;
}
public aiScene ReadFileFromMemory(SWIGTYPE_p_void pBuffer, uint pLength, uint pFlags, string pHint) {
IntPtr cPtr = Assimp_NETPINVOKE.Importer_ReadFileFromMemory__SWIG_0(swigCPtr, SWIGTYPE_p_void.getCPtr(pBuffer), pLength, pFlags, pHint);
aiScene ret = (cPtr == IntPtr.Zero) ? null : new aiScene(cPtr, false);
return ret;
}
public aiScene ReadFileFromMemory(SWIGTYPE_p_void pBuffer, uint pLength, uint pFlags) {
IntPtr cPtr = Assimp_NETPINVOKE.Importer_ReadFileFromMemory__SWIG_1(swigCPtr, SWIGTYPE_p_void.getCPtr(pBuffer), pLength, pFlags);
aiScene ret = (cPtr == IntPtr.Zero) ? null : new aiScene(cPtr, false);
return ret;
}
public aiScene ApplyPostProcessing(uint pFlags) {
IntPtr cPtr = Assimp_NETPINVOKE.Importer_ApplyPostProcessing(swigCPtr, pFlags);
aiScene ret = (cPtr == IntPtr.Zero) ? null : new aiScene(cPtr, false);
return ret;
}
public aiScene ReadFile_s(string pFile, uint pFlags) {
IntPtr cPtr = Assimp_NETPINVOKE.Importer_ReadFile_s(swigCPtr, pFile, pFlags);
aiScene ret = (cPtr == IntPtr.Zero) ? null : new aiScene(cPtr, false);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void FreeScene() {
Assimp_NETPINVOKE.Importer_FreeScene(swigCPtr);
}
public string GetErrorString() {
string ret = Assimp_NETPINVOKE.Importer_GetErrorString(swigCPtr);
return ret;
}
public bool IsExtensionSupported(string szExtension) {
bool ret = Assimp_NETPINVOKE.Importer_IsExtensionSupported__SWIG_0(swigCPtr, szExtension);
return ret;
}
public void GetExtensionList(aiString szOut) {
Assimp_NETPINVOKE.Importer_GetExtensionList__SWIG_0(swigCPtr, aiString.getCPtr(szOut));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public void GetExtensionList(SWIGTYPE_p_std__string szOut) {
Assimp_NETPINVOKE.Importer_GetExtensionList__SWIG_1(swigCPtr, SWIGTYPE_p_std__string.getCPtr(szOut));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public SWIGTYPE_p_Assimp__BaseImporter FindLoader(string szExtension) {
IntPtr cPtr = Assimp_NETPINVOKE.Importer_FindLoader(swigCPtr, szExtension);
SWIGTYPE_p_Assimp__BaseImporter ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_Assimp__BaseImporter(cPtr, false);
return ret;
}
public aiScene GetScene() {
IntPtr cPtr = Assimp_NETPINVOKE.Importer_GetScene(swigCPtr);
aiScene ret = (cPtr == IntPtr.Zero) ? null : new aiScene(cPtr, false);
return ret;
}
public aiScene GetOrphanedScene() {
IntPtr cPtr = Assimp_NETPINVOKE.Importer_GetOrphanedScene(swigCPtr);
aiScene ret = (cPtr == IntPtr.Zero) ? null : new aiScene(cPtr, false);
return ret;
}
public void GetMemoryRequirements(aiMemoryInfo arg0) {
Assimp_NETPINVOKE.Importer_GetMemoryRequirements(swigCPtr, aiMemoryInfo.getCPtr(arg0));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public void SetExtraVerbose(bool bDo) {
Assimp_NETPINVOKE.Importer_SetExtraVerbose(swigCPtr, bDo);
}
}

65
port/Assimp.NET/Assimp.NET_CS/LogStream.cs 100644
View File

@ -0,0 +1,65 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class LogStream : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal LogStream(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(LogStream obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~LogStream() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_LogStream(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public virtual void write(string message) {
Assimp_NETPINVOKE.LogStream_write(swigCPtr, message);
}
public static LogStream createDefaultStream(aiDefaultLogStream stream, string name, IOSystem io) {
IntPtr cPtr = Assimp_NETPINVOKE.LogStream_createDefaultStream__SWIG_0((int)stream, name, IOSystem.getCPtr(io));
LogStream ret = (cPtr == IntPtr.Zero) ? null : new LogStream(cPtr, false);
return ret;
}
public static LogStream createDefaultStream(aiDefaultLogStream stream, string name) {
IntPtr cPtr = Assimp_NETPINVOKE.LogStream_createDefaultStream__SWIG_1((int)stream, name);
LogStream ret = (cPtr == IntPtr.Zero) ? null : new LogStream(cPtr, false);
return ret;
}
public static LogStream createDefaultStream(aiDefaultLogStream stream) {
IntPtr cPtr = Assimp_NETPINVOKE.LogStream_createDefaultStream__SWIG_2((int)stream);
LogStream ret = (cPtr == IntPtr.Zero) ? null : new LogStream(cPtr, false);
return ret;
}
}

104
port/Assimp.NET/Assimp.NET_CS/Logger.cs 100644
View File

@ -0,0 +1,104 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class Logger : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal Logger(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(Logger obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~Logger() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_Logger(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public void debug(string message) {
Assimp_NETPINVOKE.Logger_debug(swigCPtr, message);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public void info(string message) {
Assimp_NETPINVOKE.Logger_info(swigCPtr, message);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public void warn(string message) {
Assimp_NETPINVOKE.Logger_warn(swigCPtr, message);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public void error(string message) {
Assimp_NETPINVOKE.Logger_error(swigCPtr, message);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public void setLogSeverity(Logger.LogSeverity log_severity) {
Assimp_NETPINVOKE.Logger_setLogSeverity(swigCPtr, (int)log_severity);
}
public Logger.LogSeverity getLogSeverity() {
Logger.LogSeverity ret = (Logger.LogSeverity)Assimp_NETPINVOKE.Logger_getLogSeverity(swigCPtr);
return ret;
}
public virtual bool attachStream(LogStream pStream, uint severity) {
bool ret = Assimp_NETPINVOKE.Logger_attachStream__SWIG_0(swigCPtr, LogStream.getCPtr(pStream), severity);
return ret;
}
public virtual bool attachStream(LogStream pStream) {
bool ret = Assimp_NETPINVOKE.Logger_attachStream__SWIG_1(swigCPtr, LogStream.getCPtr(pStream));
return ret;
}
public virtual bool detatchStream(LogStream pStream, uint severity) {
bool ret = Assimp_NETPINVOKE.Logger_detatchStream__SWIG_0(swigCPtr, LogStream.getCPtr(pStream), severity);
return ret;
}
public virtual bool detatchStream(LogStream pStream) {
bool ret = Assimp_NETPINVOKE.Logger_detatchStream__SWIG_1(swigCPtr, LogStream.getCPtr(pStream));
return ret;
}
public enum LogSeverity {
NORMAL,
VERBOSE
}
public enum ErrorSeverity {
DEBUGGING = 1,
INFO = 2,
WARN = 4,
ERR = 8
}
}

68
port/Assimp.NET/Assimp.NET_CS/NullLogger.cs 100644
View File

@ -0,0 +1,68 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class NullLogger : Logger {
private HandleRef swigCPtr;
internal NullLogger(IntPtr cPtr, bool cMemoryOwn) : base(Assimp_NETPINVOKE.NullLoggerUpcast(cPtr), cMemoryOwn) {
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(NullLogger obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~NullLogger() {
Dispose();
}
public override void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_NullLogger(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
base.Dispose();
}
}
public virtual void OnDebug(string message) {
Assimp_NETPINVOKE.NullLogger_OnDebug(swigCPtr, message);
}
public virtual void OnInfo(string message) {
Assimp_NETPINVOKE.NullLogger_OnInfo(swigCPtr, message);
}
public virtual void OnWarn(string message) {
Assimp_NETPINVOKE.NullLogger_OnWarn(swigCPtr, message);
}
public virtual void OnError(string message) {
Assimp_NETPINVOKE.NullLogger_OnError(swigCPtr, message);
}
public override bool attachStream(LogStream pStream, uint severity) {
bool ret = Assimp_NETPINVOKE.NullLogger_attachStream(swigCPtr, LogStream.getCPtr(pStream), severity);
return ret;
}
public override bool detatchStream(LogStream pStream, uint severity) {
bool ret = Assimp_NETPINVOKE.NullLogger_detatchStream(swigCPtr, LogStream.getCPtr(pStream), severity);
return ret;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_Assimp__BaseImporter.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_Assimp__BaseImporter {
private HandleRef swigCPtr;
internal SWIGTYPE_p_Assimp__BaseImporter(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_Assimp__BaseImporter() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_Assimp__BaseImporter obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_Assimp__BaseProcess.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_Assimp__BaseProcess {
private HandleRef swigCPtr;
internal SWIGTYPE_p_Assimp__BaseProcess(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_Assimp__BaseProcess() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_Assimp__BaseProcess obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_aiColor4D.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_aiColor4D {
private HandleRef swigCPtr;
internal SWIGTYPE_p_aiColor4D(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_aiColor4D() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_aiColor4D obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_aiTextureMapMode.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_aiTextureMapMode {
private HandleRef swigCPtr;
internal SWIGTYPE_p_aiTextureMapMode(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_aiTextureMapMode() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_aiTextureMapMode obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_aiTextureMapping.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_aiTextureMapping {
private HandleRef swigCPtr;
internal SWIGTYPE_p_aiTextureMapping(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_aiTextureMapping() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_aiTextureMapping obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_aiTextureOp.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_aiTextureOp {
private HandleRef swigCPtr;
internal SWIGTYPE_p_aiTextureOp(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_aiTextureOp() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_aiTextureOp obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_bool.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_bool {
private HandleRef swigCPtr;
internal SWIGTYPE_p_bool(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_bool() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_bool obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_f_p_aiFileIO_p_aiFile__void.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_f_p_aiFileIO_p_aiFile__void {
private HandleRef swigCPtr;
internal SWIGTYPE_p_f_p_aiFileIO_p_aiFile__void(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_f_p_aiFileIO_p_aiFile__void() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_f_p_aiFileIO_p_aiFile__void obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_f_p_aiFileIO_p_q_const__char_p_q_const__char__p_aiFile.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_f_p_aiFileIO_p_q_const__char_p_q_const__char__p_aiFile {
private HandleRef swigCPtr;
internal SWIGTYPE_p_f_p_aiFileIO_p_q_const__char_p_q_const__char__p_aiFile(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_f_p_aiFileIO_p_q_const__char_p_q_const__char__p_aiFile() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_f_p_aiFileIO_p_q_const__char_p_q_const__char__p_aiFile obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_f_p_aiFile__size_t.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_f_p_aiFile__size_t {
private HandleRef swigCPtr;
internal SWIGTYPE_p_f_p_aiFile__size_t(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_f_p_aiFile__size_t() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_f_p_aiFile__size_t obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_f_p_aiFile__void.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_f_p_aiFile__void {
private HandleRef swigCPtr;
internal SWIGTYPE_p_f_p_aiFile__void(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_f_p_aiFile__void() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_f_p_aiFile__void obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_f_p_aiFile_p_char_size_t_size_t__size_t.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_f_p_aiFile_p_char_size_t_size_t__size_t {
private HandleRef swigCPtr;
internal SWIGTYPE_p_f_p_aiFile_p_char_size_t_size_t__size_t(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_f_p_aiFile_p_char_size_t_size_t__size_t() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_f_p_aiFile_p_char_size_t_size_t__size_t obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_f_p_aiFile_p_q_const__char_size_t_size_t__size_t.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_f_p_aiFile_p_q_const__char_size_t_size_t__size_t {
private HandleRef swigCPtr;
internal SWIGTYPE_p_f_p_aiFile_p_q_const__char_size_t_size_t__size_t(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_f_p_aiFile_p_q_const__char_size_t_size_t__size_t() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_f_p_aiFile_p_q_const__char_size_t_size_t__size_t obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_f_p_aiFile_size_t_enum_aiOrigin__aiReturn.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_f_p_aiFile_size_t_enum_aiOrigin__aiReturn {
private HandleRef swigCPtr;
internal SWIGTYPE_p_f_p_aiFile_size_t_enum_aiOrigin__aiReturn(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_f_p_aiFile_size_t_enum_aiOrigin__aiReturn() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_f_p_aiFile_size_t_enum_aiOrigin__aiReturn obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_float.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_float {
private HandleRef swigCPtr;
internal SWIGTYPE_p_float(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_float() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_float obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_int.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_int {
private HandleRef swigCPtr;
internal SWIGTYPE_p_int(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_int() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_int obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_p_aiAnimMesh.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_p_aiAnimMesh {
private HandleRef swigCPtr;
internal SWIGTYPE_p_p_aiAnimMesh(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_p_aiAnimMesh() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_p_aiAnimMesh obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

8
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_std__nothrow_t.cs → port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_p_aiAnimation.cs
View File

@ -10,18 +10,18 @@
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_std__nothrow_t {
public class SWIGTYPE_p_p_aiAnimation {
private HandleRef swigCPtr;
internal SWIGTYPE_p_std__nothrow_t(IntPtr cPtr, bool futureUse) {
internal SWIGTYPE_p_p_aiAnimation(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_std__nothrow_t() {
protected SWIGTYPE_p_p_aiAnimation() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_std__nothrow_t obj) {
internal static HandleRef getCPtr(SWIGTYPE_p_p_aiAnimation obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_p_aiBone.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_p_aiBone {
private HandleRef swigCPtr;
internal SWIGTYPE_p_p_aiBone(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_p_aiBone() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_p_aiBone obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_p_aiCamera.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_p_aiCamera {
private HandleRef swigCPtr;
internal SWIGTYPE_p_p_aiCamera(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_p_aiCamera() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_p_aiCamera obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_p_aiColor4D.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_p_aiColor4D {
private HandleRef swigCPtr;
internal SWIGTYPE_p_p_aiColor4D(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_p_aiColor4D() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_p_aiColor4D obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_p_aiLight.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_p_aiLight {
private HandleRef swigCPtr;
internal SWIGTYPE_p_p_aiLight(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_p_aiLight() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_p_aiLight obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_p_aiMaterial.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_p_aiMaterial {
private HandleRef swigCPtr;
internal SWIGTYPE_p_p_aiMaterial(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_p_aiMaterial() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_p_aiMaterial obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_p_aiMaterialProperty.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_p_aiMaterialProperty {
private HandleRef swigCPtr;
internal SWIGTYPE_p_p_aiMaterialProperty(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_p_aiMaterialProperty() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_p_aiMaterialProperty obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_p_aiMesh.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_p_aiMesh {
private HandleRef swigCPtr;
internal SWIGTYPE_p_p_aiMesh(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_p_aiMesh() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_p_aiMesh obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_p_aiMeshAnim.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_p_aiMeshAnim {
private HandleRef swigCPtr;
internal SWIGTYPE_p_p_aiMeshAnim(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_p_aiMeshAnim() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_p_aiMeshAnim obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_p_aiNode.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_p_aiNode {
private HandleRef swigCPtr;
internal SWIGTYPE_p_p_aiNode(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_p_aiNode() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_p_aiNode obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_p_aiNodeAnim.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_p_aiNodeAnim {
private HandleRef swigCPtr;
internal SWIGTYPE_p_p_aiNodeAnim(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_p_aiNodeAnim() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_p_aiNodeAnim obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_p_aiTexture.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_p_aiTexture {
private HandleRef swigCPtr;
internal SWIGTYPE_p_p_aiTexture(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_p_aiTexture() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_p_aiTexture obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_p_aiVector3D.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_p_aiVector3D {
private HandleRef swigCPtr;
internal SWIGTYPE_p_p_aiVector3D(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_p_aiVector3D() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_p_aiVector3D obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_std__string.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_std__string {
private HandleRef swigCPtr;
internal SWIGTYPE_p_std__string(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_std__string() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_std__string obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_unsigned_int.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_unsigned_int {
private HandleRef swigCPtr;
internal SWIGTYPE_p_unsigned_int(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_unsigned_int() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_unsigned_int obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

27
port/Assimp.NET/Assimp.NET_CS/SWIGTYPE_p_void.cs 100644
View File

@ -0,0 +1,27 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class SWIGTYPE_p_void {
private HandleRef swigCPtr;
internal SWIGTYPE_p_void(IntPtr cPtr, bool futureUse) {
swigCPtr = new HandleRef(this, cPtr);
}
protected SWIGTYPE_p_void() {
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
internal static HandleRef getCPtr(SWIGTYPE_p_void obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
}

346
port/Assimp.NET/Assimp.NET_CS/UintVector.cs
View File

@ -1,346 +0,0 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class UintVector : IDisposable, System.Collections.IEnumerable
#if !SWIG_DOTNET_1
, System.Collections.Generic.IList<uint>
#endif
{
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal UintVector(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(UintVector obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~UintVector() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
AssimpPINVOKE.delete_UintVector(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public UintVector(System.Collections.ICollection c) : this() {
if (c == null)
throw new ArgumentNullException("c");
foreach (uint element in c) {
this.Add(element);
}
}
public bool IsFixedSize {
get {
return false;
}
}
public bool IsReadOnly {
get {
return false;
}
}
public uint this[int index] {
get {
return getitem(index);
}
set {
setitem(index, value);
}
}
public int Capacity {
get {
return (int)capacity();
}
set {
if (value < size())
throw new ArgumentOutOfRangeException("Capacity");
reserve((uint)value);
}
}
public int Count {
get {
return (int)size();
}
}
public bool IsSynchronized {
get {
return false;
}
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array)
#else
public void CopyTo(uint[] array)
#endif
{
CopyTo(0, array, 0, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array, int arrayIndex)
#else
public void CopyTo(uint[] array, int arrayIndex)
#endif
{
CopyTo(0, array, arrayIndex, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(int index, System.Array array, int arrayIndex, int count)
#else
public void CopyTo(int index, uint[] array, int arrayIndex, int count)
#endif
{
if (array == null)
throw new ArgumentNullException("array");
if (index < 0)
throw new ArgumentOutOfRangeException("index", "Value is less than zero");
if (arrayIndex < 0)
throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
if (count < 0)
throw new ArgumentOutOfRangeException("count", "Value is less than zero");
if (array.Rank > 1)
throw new ArgumentException("Multi dimensional array.", "array");
if (index+count > this.Count || arrayIndex+count > array.Length)
throw new ArgumentException("Number of elements to copy is too large.");
for (int i=0; i<count; i++)
array.SetValue(getitemcopy(index+i), arrayIndex+i);
}
#if !SWIG_DOTNET_1
System.Collections.Generic.IEnumerator<uint> System.Collections.Generic.IEnumerable<uint>.GetEnumerator() {
return new UintVectorEnumerator(this);
}
#endif
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
return new UintVectorEnumerator(this);
}
public UintVectorEnumerator GetEnumerator() {
return new UintVectorEnumerator(this);
}
// Type-safe enumerator
/// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
/// whenever the collection is modified. This has been done for changes in the size of the
/// collection but not when one of the elements of the collection is modified as it is a bit
/// tricky to detect unmanaged code that modifies the collection under our feet.
public sealed class UintVectorEnumerator : System.Collections.IEnumerator
#if !SWIG_DOTNET_1
, System.Collections.Generic.IEnumerator<uint>
#endif
{
private UintVector collectionRef;
private int currentIndex;
private object currentObject;
private int currentSize;
public UintVectorEnumerator(UintVector collection) {
collectionRef = collection;
currentIndex = -1;
currentObject = null;
currentSize = collectionRef.Count;
}
// Type-safe iterator Current
public uint Current {
get {
if (currentIndex == -1)
throw new InvalidOperationException("Enumeration not started.");
if (currentIndex > currentSize - 1)
throw new InvalidOperationException("Enumeration finished.");
if (currentObject == null)
throw new InvalidOperationException("Collection modified.");
return (uint)currentObject;
}
}
// Type-unsafe IEnumerator.Current
object System.Collections.IEnumerator.Current {
get {
return Current;
}
}
public bool MoveNext() {
int size = collectionRef.Count;
bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
if (moveOkay) {
currentIndex++;
currentObject = collectionRef[currentIndex];
} else {
currentObject = null;
}
return moveOkay;
}
public void Reset() {
currentIndex = -1;
currentObject = null;
if (collectionRef.Count != currentSize) {
throw new InvalidOperationException("Collection modified.");
}
}
#if !SWIG_DOTNET_1
public void Dispose() {
currentIndex = -1;
currentObject = null;
}
#endif
}
public void Clear() {
AssimpPINVOKE.UintVector_Clear(swigCPtr);
}
public void Add(uint x) {
AssimpPINVOKE.UintVector_Add(swigCPtr, x);
}
private uint size() {
uint ret = AssimpPINVOKE.UintVector_size(swigCPtr);
return ret;
}
private uint capacity() {
uint ret = AssimpPINVOKE.UintVector_capacity(swigCPtr);
return ret;
}
private void reserve(uint n) {
AssimpPINVOKE.UintVector_reserve(swigCPtr, n);
}
public UintVector() : this(AssimpPINVOKE.new_UintVector__SWIG_0(), true) {
}
public UintVector(UintVector other) : this(AssimpPINVOKE.new_UintVector__SWIG_1(UintVector.getCPtr(other)), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public UintVector(int capacity) : this(AssimpPINVOKE.new_UintVector__SWIG_2(capacity), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
private uint getitemcopy(int index) {
uint ret = AssimpPINVOKE.UintVector_getitemcopy(swigCPtr, index);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private uint getitem(int index) {
uint ret = AssimpPINVOKE.UintVector_getitem(swigCPtr, index);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private void setitem(int index, uint val) {
AssimpPINVOKE.UintVector_setitem(swigCPtr, index, val);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void AddRange(UintVector values) {
AssimpPINVOKE.UintVector_AddRange(swigCPtr, UintVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public UintVector GetRange(int index, int count) {
IntPtr cPtr = AssimpPINVOKE.UintVector_GetRange(swigCPtr, index, count);
UintVector ret = (cPtr == IntPtr.Zero) ? null : new UintVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Insert(int index, uint x) {
AssimpPINVOKE.UintVector_Insert(swigCPtr, index, x);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void InsertRange(int index, UintVector values) {
AssimpPINVOKE.UintVector_InsertRange(swigCPtr, index, UintVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveAt(int index) {
AssimpPINVOKE.UintVector_RemoveAt(swigCPtr, index);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveRange(int index, int count) {
AssimpPINVOKE.UintVector_RemoveRange(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public static UintVector Repeat(uint value, int count) {
IntPtr cPtr = AssimpPINVOKE.UintVector_Repeat(value, count);
UintVector ret = (cPtr == IntPtr.Zero) ? null : new UintVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Reverse() {
AssimpPINVOKE.UintVector_Reverse__SWIG_0(swigCPtr);
}
public void Reverse(int index, int count) {
AssimpPINVOKE.UintVector_Reverse__SWIG_1(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void SetRange(int index, UintVector values) {
AssimpPINVOKE.UintVector_SetRange(swigCPtr, index, UintVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public bool Contains(uint value) {
bool ret = AssimpPINVOKE.UintVector_Contains(swigCPtr, value);
return ret;
}
public int IndexOf(uint value) {
int ret = AssimpPINVOKE.UintVector_IndexOf(swigCPtr, value);
return ret;
}
public int LastIndexOf(uint value) {
int ret = AssimpPINVOKE.UintVector_LastIndexOf(swigCPtr, value);
return ret;
}
public bool Remove(uint value) {
bool ret = AssimpPINVOKE.UintVector_Remove(swigCPtr, value);
return ret;
}
}

15
port/Assimp.NET/Assimp.NET_CS/aiAnimBehaviour.cs 100644
View File

@ -0,0 +1,15 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
public enum aiAnimBehaviour {
aiAnimBehaviour_DEFAULT = 0x0,
aiAnimBehaviour_CONSTANT = 0x1,
aiAnimBehaviour_LINEAR = 0x2,
aiAnimBehaviour_REPEAT = 0x3
}

137
port/Assimp.NET/Assimp.NET_CS/aiAnimMesh.cs 100644
View File

@ -0,0 +1,137 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiAnimMesh : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiAnimMesh(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiAnimMesh obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiAnimMesh() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiAnimMesh(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiVector3D mVertices {
set {
Assimp_NETPINVOKE.aiAnimMesh_mVertices_set(swigCPtr, aiVector3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiAnimMesh_mVertices_get(swigCPtr);
aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
return ret;
}
}
public aiVector3D mNormals {
set {
Assimp_NETPINVOKE.aiAnimMesh_mNormals_set(swigCPtr, aiVector3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiAnimMesh_mNormals_get(swigCPtr);
aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
return ret;
}
}
public aiVector3D mTangents {
set {
Assimp_NETPINVOKE.aiAnimMesh_mTangents_set(swigCPtr, aiVector3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiAnimMesh_mTangents_get(swigCPtr);
aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
return ret;
}
}
public aiVector3D mBitangents {
set {
Assimp_NETPINVOKE.aiAnimMesh_mBitangents_set(swigCPtr, aiVector3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiAnimMesh_mBitangents_get(swigCPtr);
aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
return ret;
}
}
public SWIGTYPE_p_p_aiColor4D mColors {
set {
Assimp_NETPINVOKE.aiAnimMesh_mColors_set(swigCPtr, SWIGTYPE_p_p_aiColor4D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiAnimMesh_mColors_get(swigCPtr);
SWIGTYPE_p_p_aiColor4D ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_p_aiColor4D(cPtr, false);
return ret;
}
}
public SWIGTYPE_p_p_aiVector3D mTextureCoords {
set {
Assimp_NETPINVOKE.aiAnimMesh_mTextureCoords_set(swigCPtr, SWIGTYPE_p_p_aiVector3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiAnimMesh_mTextureCoords_get(swigCPtr);
SWIGTYPE_p_p_aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_p_aiVector3D(cPtr, false);
return ret;
}
}
public aiAnimMesh() : this(Assimp_NETPINVOKE.new_aiAnimMesh(), true) {
}
public bool HasPositions() {
bool ret = Assimp_NETPINVOKE.aiAnimMesh_HasPositions(swigCPtr);
return ret;
}
public bool HasNormals() {
bool ret = Assimp_NETPINVOKE.aiAnimMesh_HasNormals(swigCPtr);
return ret;
}
public bool HasTangentsAndBitangents() {
bool ret = Assimp_NETPINVOKE.aiAnimMesh_HasTangentsAndBitangents(swigCPtr);
return ret;
}
public bool HasVertexColors(uint pIndex) {
bool ret = Assimp_NETPINVOKE.aiAnimMesh_HasVertexColors(swigCPtr, pIndex);
return ret;
}
public bool HasTextureCoords(uint pIndex) {
bool ret = Assimp_NETPINVOKE.aiAnimMesh_HasTextureCoords(swigCPtr, pIndex);
return ret;
}
}

119
port/Assimp.NET/Assimp.NET_CS/aiAnimation.cs 100644
View File

@ -0,0 +1,119 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiAnimation : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiAnimation(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiAnimation obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiAnimation() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiAnimation(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiString mName {
set {
Assimp_NETPINVOKE.aiAnimation_mName_set(swigCPtr, aiString.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiAnimation_mName_get(swigCPtr);
aiString ret = (cPtr == IntPtr.Zero) ? null : new aiString(cPtr, false);
return ret;
}
}
public double mDuration {
set {
Assimp_NETPINVOKE.aiAnimation_mDuration_set(swigCPtr, value);
}
get {
double ret = Assimp_NETPINVOKE.aiAnimation_mDuration_get(swigCPtr);
return ret;
}
}
public double mTicksPerSecond {
set {
Assimp_NETPINVOKE.aiAnimation_mTicksPerSecond_set(swigCPtr, value);
}
get {
double ret = Assimp_NETPINVOKE.aiAnimation_mTicksPerSecond_get(swigCPtr);
return ret;
}
}
public uint mNumChannels {
set {
Assimp_NETPINVOKE.aiAnimation_mNumChannels_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiAnimation_mNumChannels_get(swigCPtr);
return ret;
}
}
public SWIGTYPE_p_p_aiNodeAnim mChannels {
set {
Assimp_NETPINVOKE.aiAnimation_mChannels_set(swigCPtr, SWIGTYPE_p_p_aiNodeAnim.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiAnimation_mChannels_get(swigCPtr);
SWIGTYPE_p_p_aiNodeAnim ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_p_aiNodeAnim(cPtr, false);
return ret;
}
}
public uint mNumMeshChannels {
set {
Assimp_NETPINVOKE.aiAnimation_mNumMeshChannels_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiAnimation_mNumMeshChannels_get(swigCPtr);
return ret;
}
}
public SWIGTYPE_p_p_aiMeshAnim mMeshChannels {
set {
Assimp_NETPINVOKE.aiAnimation_mMeshChannels_set(swigCPtr, SWIGTYPE_p_p_aiMeshAnim.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiAnimation_mMeshChannels_get(swigCPtr);
SWIGTYPE_p_p_aiMeshAnim ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_p_aiMeshAnim(cPtr, false);
return ret;
}
}
public aiAnimation() : this(Assimp_NETPINVOKE.new_aiAnimation(), true) {
}
}

348
port/Assimp.NET/Assimp.NET_CS/aiAnimationVector.cs
View File

@ -1,348 +0,0 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiAnimationVector : IDisposable, System.Collections.IEnumerable
#if !SWIG_DOTNET_1
, System.Collections.Generic.IList<aiAnimation>
#endif
{
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiAnimationVector(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiAnimationVector obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiAnimationVector() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
AssimpPINVOKE.delete_aiAnimationVector(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiAnimationVector(System.Collections.ICollection c) : this() {
if (c == null)
throw new ArgumentNullException("c");
foreach (aiAnimation element in c) {
this.Add(element);
}
}
public bool IsFixedSize {
get {
return false;
}
}
public bool IsReadOnly {
get {
return false;
}
}
public aiAnimation this[int index] {
get {
return getitem(index);
}
set {
setitem(index, value);
}
}
public int Capacity {
get {
return (int)capacity();
}
set {
if (value < size())
throw new ArgumentOutOfRangeException("Capacity");
reserve((uint)value);
}
}
public int Count {
get {
return (int)size();
}
}
public bool IsSynchronized {
get {
return false;
}
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array)
#else
public void CopyTo(aiAnimation[] array)
#endif
{
CopyTo(0, array, 0, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array, int arrayIndex)
#else
public void CopyTo(aiAnimation[] array, int arrayIndex)
#endif
{
CopyTo(0, array, arrayIndex, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(int index, System.Array array, int arrayIndex, int count)
#else
public void CopyTo(int index, aiAnimation[] array, int arrayIndex, int count)
#endif
{
if (array == null)
throw new ArgumentNullException("array");
if (index < 0)
throw new ArgumentOutOfRangeException("index", "Value is less than zero");
if (arrayIndex < 0)
throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
if (count < 0)
throw new ArgumentOutOfRangeException("count", "Value is less than zero");
if (array.Rank > 1)
throw new ArgumentException("Multi dimensional array.", "array");
if (index+count > this.Count || arrayIndex+count > array.Length)
throw new ArgumentException("Number of elements to copy is too large.");
for (int i=0; i<count; i++)
array.SetValue(getitemcopy(index+i), arrayIndex+i);
}
#if !SWIG_DOTNET_1
System.Collections.Generic.IEnumerator<aiAnimation> System.Collections.Generic.IEnumerable<aiAnimation>.GetEnumerator() {
return new aiAnimationVectorEnumerator(this);
}
#endif
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
return new aiAnimationVectorEnumerator(this);
}
public aiAnimationVectorEnumerator GetEnumerator() {
return new aiAnimationVectorEnumerator(this);
}
// Type-safe enumerator
/// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
/// whenever the collection is modified. This has been done for changes in the size of the
/// collection but not when one of the elements of the collection is modified as it is a bit
/// tricky to detect unmanaged code that modifies the collection under our feet.
public sealed class aiAnimationVectorEnumerator : System.Collections.IEnumerator
#if !SWIG_DOTNET_1
, System.Collections.Generic.IEnumerator<aiAnimation>
#endif
{
private aiAnimationVector collectionRef;
private int currentIndex;
private object currentObject;
private int currentSize;
public aiAnimationVectorEnumerator(aiAnimationVector collection) {
collectionRef = collection;
currentIndex = -1;
currentObject = null;
currentSize = collectionRef.Count;
}
// Type-safe iterator Current
public aiAnimation Current {
get {
if (currentIndex == -1)
throw new InvalidOperationException("Enumeration not started.");
if (currentIndex > currentSize - 1)
throw new InvalidOperationException("Enumeration finished.");
if (currentObject == null)
throw new InvalidOperationException("Collection modified.");
return (aiAnimation)currentObject;
}
}
// Type-unsafe IEnumerator.Current
object System.Collections.IEnumerator.Current {
get {
return Current;
}
}
public bool MoveNext() {
int size = collectionRef.Count;
bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
if (moveOkay) {
currentIndex++;
currentObject = collectionRef[currentIndex];
} else {
currentObject = null;
}
return moveOkay;
}
public void Reset() {
currentIndex = -1;
currentObject = null;
if (collectionRef.Count != currentSize) {
throw new InvalidOperationException("Collection modified.");
}
}
#if !SWIG_DOTNET_1
public void Dispose() {
currentIndex = -1;
currentObject = null;
}
#endif
}
public void Clear() {
AssimpPINVOKE.aiAnimationVector_Clear(swigCPtr);
}
public void Add(aiAnimation x) {
AssimpPINVOKE.aiAnimationVector_Add(swigCPtr, aiAnimation.getCPtr(x));
}
private uint size() {
uint ret = AssimpPINVOKE.aiAnimationVector_size(swigCPtr);
return ret;
}
private uint capacity() {
uint ret = AssimpPINVOKE.aiAnimationVector_capacity(swigCPtr);
return ret;
}
private void reserve(uint n) {
AssimpPINVOKE.aiAnimationVector_reserve(swigCPtr, n);
}
public aiAnimationVector() : this(AssimpPINVOKE.new_aiAnimationVector__SWIG_0(), true) {
}
public aiAnimationVector(aiAnimationVector other) : this(AssimpPINVOKE.new_aiAnimationVector__SWIG_1(aiAnimationVector.getCPtr(other)), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiAnimationVector(int capacity) : this(AssimpPINVOKE.new_aiAnimationVector__SWIG_2(capacity), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
private aiAnimation getitemcopy(int index) {
IntPtr cPtr = AssimpPINVOKE.aiAnimationVector_getitemcopy(swigCPtr, index);
aiAnimation ret = (cPtr == IntPtr.Zero) ? null : new aiAnimation(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private aiAnimation getitem(int index) {
IntPtr cPtr = AssimpPINVOKE.aiAnimationVector_getitem(swigCPtr, index);
aiAnimation ret = (cPtr == IntPtr.Zero) ? null : new aiAnimation(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private void setitem(int index, aiAnimation val) {
AssimpPINVOKE.aiAnimationVector_setitem(swigCPtr, index, aiAnimation.getCPtr(val));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void AddRange(aiAnimationVector values) {
AssimpPINVOKE.aiAnimationVector_AddRange(swigCPtr, aiAnimationVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiAnimationVector GetRange(int index, int count) {
IntPtr cPtr = AssimpPINVOKE.aiAnimationVector_GetRange(swigCPtr, index, count);
aiAnimationVector ret = (cPtr == IntPtr.Zero) ? null : new aiAnimationVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Insert(int index, aiAnimation x) {
AssimpPINVOKE.aiAnimationVector_Insert(swigCPtr, index, aiAnimation.getCPtr(x));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void InsertRange(int index, aiAnimationVector values) {
AssimpPINVOKE.aiAnimationVector_InsertRange(swigCPtr, index, aiAnimationVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveAt(int index) {
AssimpPINVOKE.aiAnimationVector_RemoveAt(swigCPtr, index);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveRange(int index, int count) {
AssimpPINVOKE.aiAnimationVector_RemoveRange(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public static aiAnimationVector Repeat(aiAnimation value, int count) {
IntPtr cPtr = AssimpPINVOKE.aiAnimationVector_Repeat(aiAnimation.getCPtr(value), count);
aiAnimationVector ret = (cPtr == IntPtr.Zero) ? null : new aiAnimationVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Reverse() {
AssimpPINVOKE.aiAnimationVector_Reverse__SWIG_0(swigCPtr);
}
public void Reverse(int index, int count) {
AssimpPINVOKE.aiAnimationVector_Reverse__SWIG_1(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void SetRange(int index, aiAnimationVector values) {
AssimpPINVOKE.aiAnimationVector_SetRange(swigCPtr, index, aiAnimationVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public bool Contains(aiAnimation value) {
bool ret = AssimpPINVOKE.aiAnimationVector_Contains(swigCPtr, aiAnimation.getCPtr(value));
return ret;
}
public int IndexOf(aiAnimation value) {
int ret = AssimpPINVOKE.aiAnimationVector_IndexOf(swigCPtr, aiAnimation.getCPtr(value));
return ret;
}
public int LastIndexOf(aiAnimation value) {
int ret = AssimpPINVOKE.aiAnimationVector_LastIndexOf(swigCPtr, aiAnimation.getCPtr(value));
return ret;
}
public bool Remove(aiAnimation value) {
bool ret = AssimpPINVOKE.aiAnimationVector_Remove(swigCPtr, aiAnimation.getCPtr(value));
return ret;
}
}

13
port/Assimp.NET/Assimp.NET_CS/aiBlendMode.cs 100644
View File

@ -0,0 +1,13 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
public enum aiBlendMode {
aiBlendMode_Default = 0x0,
aiBlendMode_Additive = 0x1
}

93
port/Assimp.NET/Assimp.NET_CS/aiBone.cs 100644
View File

@ -0,0 +1,93 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiBone : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiBone(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiBone obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiBone() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiBone(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiString mName {
set {
Assimp_NETPINVOKE.aiBone_mName_set(swigCPtr, aiString.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiBone_mName_get(swigCPtr);
aiString ret = (cPtr == IntPtr.Zero) ? null : new aiString(cPtr, false);
return ret;
}
}
public uint mNumWeights {
set {
Assimp_NETPINVOKE.aiBone_mNumWeights_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiBone_mNumWeights_get(swigCPtr);
return ret;
}
}
public aiVertexWeight mWeights {
set {
Assimp_NETPINVOKE.aiBone_mWeights_set(swigCPtr, aiVertexWeight.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiBone_mWeights_get(swigCPtr);
aiVertexWeight ret = (cPtr == IntPtr.Zero) ? null : new aiVertexWeight(cPtr, false);
return ret;
}
}
public aiMatrix4x4 mOffsetMatrix {
set {
Assimp_NETPINVOKE.aiBone_mOffsetMatrix_set(swigCPtr, aiMatrix4x4.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiBone_mOffsetMatrix_get(swigCPtr);
aiMatrix4x4 ret = (cPtr == IntPtr.Zero) ? null : new aiMatrix4x4(cPtr, false);
return ret;
}
}
public aiBone() : this(Assimp_NETPINVOKE.new_aiBone__SWIG_0(), true) {
}
public aiBone(aiBone other) : this(Assimp_NETPINVOKE.new_aiBone__SWIG_1(aiBone.getCPtr(other)), true) {
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
}

135
port/Assimp.NET/Assimp.NET_CS/aiCamera.cs 100644
View File

@ -0,0 +1,135 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiCamera : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiCamera(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiCamera obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiCamera() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiCamera(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiString mName {
set {
Assimp_NETPINVOKE.aiCamera_mName_set(swigCPtr, aiString.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiCamera_mName_get(swigCPtr);
aiString ret = (cPtr == IntPtr.Zero) ? null : new aiString(cPtr, false);
return ret;
}
}
public aiVector3D mPosition {
set {
Assimp_NETPINVOKE.aiCamera_mPosition_set(swigCPtr, aiVector3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiCamera_mPosition_get(swigCPtr);
aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
return ret;
}
}
public aiVector3D mUp {
set {
Assimp_NETPINVOKE.aiCamera_mUp_set(swigCPtr, aiVector3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiCamera_mUp_get(swigCPtr);
aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
return ret;
}
}
public aiVector3D mLookAt {
set {
Assimp_NETPINVOKE.aiCamera_mLookAt_set(swigCPtr, aiVector3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiCamera_mLookAt_get(swigCPtr);
aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
return ret;
}
}
public float mHorizontalFOV {
set {
Assimp_NETPINVOKE.aiCamera_mHorizontalFOV_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiCamera_mHorizontalFOV_get(swigCPtr);
return ret;
}
}
public float mClipPlaneNear {
set {
Assimp_NETPINVOKE.aiCamera_mClipPlaneNear_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiCamera_mClipPlaneNear_get(swigCPtr);
return ret;
}
}
public float mClipPlaneFar {
set {
Assimp_NETPINVOKE.aiCamera_mClipPlaneFar_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiCamera_mClipPlaneFar_get(swigCPtr);
return ret;
}
}
public float mAspect {
set {
Assimp_NETPINVOKE.aiCamera_mAspect_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiCamera_mAspect_get(swigCPtr);
return ret;
}
}
public aiCamera() : this(Assimp_NETPINVOKE.new_aiCamera(), true) {
}
public void GetCameraMatrix(aiMatrix4x4 arg0) {
Assimp_NETPINVOKE.aiCamera_GetCameraMatrix(swigCPtr, aiMatrix4x4.getCPtr(arg0));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
}

348
port/Assimp.NET/Assimp.NET_CS/aiCameraVector.cs
View File

@ -1,348 +0,0 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiCameraVector : IDisposable, System.Collections.IEnumerable
#if !SWIG_DOTNET_1
, System.Collections.Generic.IList<aiCamera>
#endif
{
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiCameraVector(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiCameraVector obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiCameraVector() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
AssimpPINVOKE.delete_aiCameraVector(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiCameraVector(System.Collections.ICollection c) : this() {
if (c == null)
throw new ArgumentNullException("c");
foreach (aiCamera element in c) {
this.Add(element);
}
}
public bool IsFixedSize {
get {
return false;
}
}
public bool IsReadOnly {
get {
return false;
}
}
public aiCamera this[int index] {
get {
return getitem(index);
}
set {
setitem(index, value);
}
}
public int Capacity {
get {
return (int)capacity();
}
set {
if (value < size())
throw new ArgumentOutOfRangeException("Capacity");
reserve((uint)value);
}
}
public int Count {
get {
return (int)size();
}
}
public bool IsSynchronized {
get {
return false;
}
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array)
#else
public void CopyTo(aiCamera[] array)
#endif
{
CopyTo(0, array, 0, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array, int arrayIndex)
#else
public void CopyTo(aiCamera[] array, int arrayIndex)
#endif
{
CopyTo(0, array, arrayIndex, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(int index, System.Array array, int arrayIndex, int count)
#else
public void CopyTo(int index, aiCamera[] array, int arrayIndex, int count)
#endif
{
if (array == null)
throw new ArgumentNullException("array");
if (index < 0)
throw new ArgumentOutOfRangeException("index", "Value is less than zero");
if (arrayIndex < 0)
throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
if (count < 0)
throw new ArgumentOutOfRangeException("count", "Value is less than zero");
if (array.Rank > 1)
throw new ArgumentException("Multi dimensional array.", "array");
if (index+count > this.Count || arrayIndex+count > array.Length)
throw new ArgumentException("Number of elements to copy is too large.");
for (int i=0; i<count; i++)
array.SetValue(getitemcopy(index+i), arrayIndex+i);
}
#if !SWIG_DOTNET_1
System.Collections.Generic.IEnumerator<aiCamera> System.Collections.Generic.IEnumerable<aiCamera>.GetEnumerator() {
return new aiCameraVectorEnumerator(this);
}
#endif
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
return new aiCameraVectorEnumerator(this);
}
public aiCameraVectorEnumerator GetEnumerator() {
return new aiCameraVectorEnumerator(this);
}
// Type-safe enumerator
/// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
/// whenever the collection is modified. This has been done for changes in the size of the
/// collection but not when one of the elements of the collection is modified as it is a bit
/// tricky to detect unmanaged code that modifies the collection under our feet.
public sealed class aiCameraVectorEnumerator : System.Collections.IEnumerator
#if !SWIG_DOTNET_1
, System.Collections.Generic.IEnumerator<aiCamera>
#endif
{
private aiCameraVector collectionRef;
private int currentIndex;
private object currentObject;
private int currentSize;
public aiCameraVectorEnumerator(aiCameraVector collection) {
collectionRef = collection;
currentIndex = -1;
currentObject = null;
currentSize = collectionRef.Count;
}
// Type-safe iterator Current
public aiCamera Current {
get {
if (currentIndex == -1)
throw new InvalidOperationException("Enumeration not started.");
if (currentIndex > currentSize - 1)
throw new InvalidOperationException("Enumeration finished.");
if (currentObject == null)
throw new InvalidOperationException("Collection modified.");
return (aiCamera)currentObject;
}
}
// Type-unsafe IEnumerator.Current
object System.Collections.IEnumerator.Current {
get {
return Current;
}
}
public bool MoveNext() {
int size = collectionRef.Count;
bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
if (moveOkay) {
currentIndex++;
currentObject = collectionRef[currentIndex];
} else {
currentObject = null;
}
return moveOkay;
}
public void Reset() {
currentIndex = -1;
currentObject = null;
if (collectionRef.Count != currentSize) {
throw new InvalidOperationException("Collection modified.");
}
}
#if !SWIG_DOTNET_1
public void Dispose() {
currentIndex = -1;
currentObject = null;
}
#endif
}
public void Clear() {
AssimpPINVOKE.aiCameraVector_Clear(swigCPtr);
}
public void Add(aiCamera x) {
AssimpPINVOKE.aiCameraVector_Add(swigCPtr, aiCamera.getCPtr(x));
}
private uint size() {
uint ret = AssimpPINVOKE.aiCameraVector_size(swigCPtr);
return ret;
}
private uint capacity() {
uint ret = AssimpPINVOKE.aiCameraVector_capacity(swigCPtr);
return ret;
}
private void reserve(uint n) {
AssimpPINVOKE.aiCameraVector_reserve(swigCPtr, n);
}
public aiCameraVector() : this(AssimpPINVOKE.new_aiCameraVector__SWIG_0(), true) {
}
public aiCameraVector(aiCameraVector other) : this(AssimpPINVOKE.new_aiCameraVector__SWIG_1(aiCameraVector.getCPtr(other)), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiCameraVector(int capacity) : this(AssimpPINVOKE.new_aiCameraVector__SWIG_2(capacity), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
private aiCamera getitemcopy(int index) {
IntPtr cPtr = AssimpPINVOKE.aiCameraVector_getitemcopy(swigCPtr, index);
aiCamera ret = (cPtr == IntPtr.Zero) ? null : new aiCamera(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private aiCamera getitem(int index) {
IntPtr cPtr = AssimpPINVOKE.aiCameraVector_getitem(swigCPtr, index);
aiCamera ret = (cPtr == IntPtr.Zero) ? null : new aiCamera(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private void setitem(int index, aiCamera val) {
AssimpPINVOKE.aiCameraVector_setitem(swigCPtr, index, aiCamera.getCPtr(val));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void AddRange(aiCameraVector values) {
AssimpPINVOKE.aiCameraVector_AddRange(swigCPtr, aiCameraVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiCameraVector GetRange(int index, int count) {
IntPtr cPtr = AssimpPINVOKE.aiCameraVector_GetRange(swigCPtr, index, count);
aiCameraVector ret = (cPtr == IntPtr.Zero) ? null : new aiCameraVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Insert(int index, aiCamera x) {
AssimpPINVOKE.aiCameraVector_Insert(swigCPtr, index, aiCamera.getCPtr(x));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void InsertRange(int index, aiCameraVector values) {
AssimpPINVOKE.aiCameraVector_InsertRange(swigCPtr, index, aiCameraVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveAt(int index) {
AssimpPINVOKE.aiCameraVector_RemoveAt(swigCPtr, index);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveRange(int index, int count) {
AssimpPINVOKE.aiCameraVector_RemoveRange(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public static aiCameraVector Repeat(aiCamera value, int count) {
IntPtr cPtr = AssimpPINVOKE.aiCameraVector_Repeat(aiCamera.getCPtr(value), count);
aiCameraVector ret = (cPtr == IntPtr.Zero) ? null : new aiCameraVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Reverse() {
AssimpPINVOKE.aiCameraVector_Reverse__SWIG_0(swigCPtr);
}
public void Reverse(int index, int count) {
AssimpPINVOKE.aiCameraVector_Reverse__SWIG_1(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void SetRange(int index, aiCameraVector values) {
AssimpPINVOKE.aiCameraVector_SetRange(swigCPtr, index, aiCameraVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public bool Contains(aiCamera value) {
bool ret = AssimpPINVOKE.aiCameraVector_Contains(swigCPtr, aiCamera.getCPtr(value));
return ret;
}
public int IndexOf(aiCamera value) {
int ret = AssimpPINVOKE.aiCameraVector_IndexOf(swigCPtr, aiCamera.getCPtr(value));
return ret;
}
public int LastIndexOf(aiCamera value) {
int ret = AssimpPINVOKE.aiCameraVector_LastIndexOf(swigCPtr, aiCamera.getCPtr(value));
return ret;
}
public bool Remove(aiCamera value) {
bool ret = AssimpPINVOKE.aiCameraVector_Remove(swigCPtr, aiCamera.getCPtr(value));
return ret;
}
}

131
port/Assimp.NET/Assimp.NET_CS/aiColor3D.cs 100644
View File

@ -0,0 +1,131 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiColor3D : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiColor3D(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiColor3D obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiColor3D() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiColor3D(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiColor3D() : this(Assimp_NETPINVOKE.new_aiColor3D__SWIG_0(), true) {
}
public aiColor3D(float _r, float _g, float _b) : this(Assimp_NETPINVOKE.new_aiColor3D__SWIG_1(_r, _g, _b), true) {
}
public aiColor3D(float _r) : this(Assimp_NETPINVOKE.new_aiColor3D__SWIG_2(_r), true) {
}
public aiColor3D(aiColor3D o) : this(Assimp_NETPINVOKE.new_aiColor3D__SWIG_3(aiColor3D.getCPtr(o)), true) {
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public bool __equal__(aiColor3D other) {
bool ret = Assimp_NETPINVOKE.aiColor3D___equal__(swigCPtr, aiColor3D.getCPtr(other));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public bool __nequal__(aiColor3D other) {
bool ret = Assimp_NETPINVOKE.aiColor3D___nequal__(swigCPtr, aiColor3D.getCPtr(other));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public aiColor3D __add__(aiColor3D c) {
aiColor3D ret = new aiColor3D(Assimp_NETPINVOKE.aiColor3D___add__(swigCPtr, aiColor3D.getCPtr(c)), true);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public aiColor3D __sub__(aiColor3D c) {
aiColor3D ret = new aiColor3D(Assimp_NETPINVOKE.aiColor3D___sub__(swigCPtr, aiColor3D.getCPtr(c)), true);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public aiColor3D __mul__(aiColor3D c) {
aiColor3D ret = new aiColor3D(Assimp_NETPINVOKE.aiColor3D___mul____SWIG_0(swigCPtr, aiColor3D.getCPtr(c)), true);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public aiColor3D __mul__(float f) {
aiColor3D ret = new aiColor3D(Assimp_NETPINVOKE.aiColor3D___mul____SWIG_1(swigCPtr, f), true);
return ret;
}
public float __idx__(uint i) {
float ret = Assimp_NETPINVOKE.aiColor3D___idx____SWIG_0(swigCPtr, i);
return ret;
}
public bool IsBlack() {
bool ret = Assimp_NETPINVOKE.aiColor3D_IsBlack(swigCPtr);
return ret;
}
public float r {
set {
Assimp_NETPINVOKE.aiColor3D_r_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiColor3D_r_get(swigCPtr);
return ret;
}
}
public float g {
set {
Assimp_NETPINVOKE.aiColor3D_g_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiColor3D_g_get(swigCPtr);
return ret;
}
}
public float b {
set {
Assimp_NETPINVOKE.aiColor3D_b_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiColor3D_b_get(swigCPtr);
return ret;
}
}
}

348
port/Assimp.NET/Assimp.NET_CS/aiColor4DVector.cs
View File

@ -1,348 +0,0 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiColor4DVector : IDisposable, System.Collections.IEnumerable
#if !SWIG_DOTNET_1
, System.Collections.Generic.IList<SWIGTYPE_p_aiColor4D>
#endif
{
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiColor4DVector(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiColor4DVector obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiColor4DVector() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
AssimpPINVOKE.delete_aiColor4DVector(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiColor4DVector(System.Collections.ICollection c) : this() {
if (c == null)
throw new ArgumentNullException("c");
foreach (SWIGTYPE_p_aiColor4D element in c) {
this.Add(element);
}
}
public bool IsFixedSize {
get {
return false;
}
}
public bool IsReadOnly {
get {
return false;
}
}
public SWIGTYPE_p_aiColor4D this[int index] {
get {
return getitem(index);
}
set {
setitem(index, value);
}
}
public int Capacity {
get {
return (int)capacity();
}
set {
if (value < size())
throw new ArgumentOutOfRangeException("Capacity");
reserve((uint)value);
}
}
public int Count {
get {
return (int)size();
}
}
public bool IsSynchronized {
get {
return false;
}
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array)
#else
public void CopyTo(SWIGTYPE_p_aiColor4D[] array)
#endif
{
CopyTo(0, array, 0, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array, int arrayIndex)
#else
public void CopyTo(SWIGTYPE_p_aiColor4D[] array, int arrayIndex)
#endif
{
CopyTo(0, array, arrayIndex, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(int index, System.Array array, int arrayIndex, int count)
#else
public void CopyTo(int index, SWIGTYPE_p_aiColor4D[] array, int arrayIndex, int count)
#endif
{
if (array == null)
throw new ArgumentNullException("array");
if (index < 0)
throw new ArgumentOutOfRangeException("index", "Value is less than zero");
if (arrayIndex < 0)
throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
if (count < 0)
throw new ArgumentOutOfRangeException("count", "Value is less than zero");
if (array.Rank > 1)
throw new ArgumentException("Multi dimensional array.", "array");
if (index+count > this.Count || arrayIndex+count > array.Length)
throw new ArgumentException("Number of elements to copy is too large.");
for (int i=0; i<count; i++)
array.SetValue(getitemcopy(index+i), arrayIndex+i);
}
#if !SWIG_DOTNET_1
System.Collections.Generic.IEnumerator<SWIGTYPE_p_aiColor4D> System.Collections.Generic.IEnumerable<SWIGTYPE_p_aiColor4D>.GetEnumerator() {
return new aiColor4DVectorEnumerator(this);
}
#endif
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
return new aiColor4DVectorEnumerator(this);
}
public aiColor4DVectorEnumerator GetEnumerator() {
return new aiColor4DVectorEnumerator(this);
}
// Type-safe enumerator
/// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
/// whenever the collection is modified. This has been done for changes in the size of the
/// collection but not when one of the elements of the collection is modified as it is a bit
/// tricky to detect unmanaged code that modifies the collection under our feet.
public sealed class aiColor4DVectorEnumerator : System.Collections.IEnumerator
#if !SWIG_DOTNET_1
, System.Collections.Generic.IEnumerator<SWIGTYPE_p_aiColor4D>
#endif
{
private aiColor4DVector collectionRef;
private int currentIndex;
private object currentObject;
private int currentSize;
public aiColor4DVectorEnumerator(aiColor4DVector collection) {
collectionRef = collection;
currentIndex = -1;
currentObject = null;
currentSize = collectionRef.Count;
}
// Type-safe iterator Current
public SWIGTYPE_p_aiColor4D Current {
get {
if (currentIndex == -1)
throw new InvalidOperationException("Enumeration not started.");
if (currentIndex > currentSize - 1)
throw new InvalidOperationException("Enumeration finished.");
if (currentObject == null)
throw new InvalidOperationException("Collection modified.");
return (SWIGTYPE_p_aiColor4D)currentObject;
}
}
// Type-unsafe IEnumerator.Current
object System.Collections.IEnumerator.Current {
get {
return Current;
}
}
public bool MoveNext() {
int size = collectionRef.Count;
bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
if (moveOkay) {
currentIndex++;
currentObject = collectionRef[currentIndex];
} else {
currentObject = null;
}
return moveOkay;
}
public void Reset() {
currentIndex = -1;
currentObject = null;
if (collectionRef.Count != currentSize) {
throw new InvalidOperationException("Collection modified.");
}
}
#if !SWIG_DOTNET_1
public void Dispose() {
currentIndex = -1;
currentObject = null;
}
#endif
}
public void Clear() {
AssimpPINVOKE.aiColor4DVector_Clear(swigCPtr);
}
public void Add(SWIGTYPE_p_aiColor4D x) {
AssimpPINVOKE.aiColor4DVector_Add(swigCPtr, SWIGTYPE_p_aiColor4D.getCPtr(x));
}
private uint size() {
uint ret = AssimpPINVOKE.aiColor4DVector_size(swigCPtr);
return ret;
}
private uint capacity() {
uint ret = AssimpPINVOKE.aiColor4DVector_capacity(swigCPtr);
return ret;
}
private void reserve(uint n) {
AssimpPINVOKE.aiColor4DVector_reserve(swigCPtr, n);
}
public aiColor4DVector() : this(AssimpPINVOKE.new_aiColor4DVector__SWIG_0(), true) {
}
public aiColor4DVector(aiColor4DVector other) : this(AssimpPINVOKE.new_aiColor4DVector__SWIG_1(aiColor4DVector.getCPtr(other)), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiColor4DVector(int capacity) : this(AssimpPINVOKE.new_aiColor4DVector__SWIG_2(capacity), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
private SWIGTYPE_p_aiColor4D getitemcopy(int index) {
IntPtr cPtr = AssimpPINVOKE.aiColor4DVector_getitemcopy(swigCPtr, index);
SWIGTYPE_p_aiColor4D ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_aiColor4D(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private SWIGTYPE_p_aiColor4D getitem(int index) {
IntPtr cPtr = AssimpPINVOKE.aiColor4DVector_getitem(swigCPtr, index);
SWIGTYPE_p_aiColor4D ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_aiColor4D(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private void setitem(int index, SWIGTYPE_p_aiColor4D val) {
AssimpPINVOKE.aiColor4DVector_setitem(swigCPtr, index, SWIGTYPE_p_aiColor4D.getCPtr(val));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void AddRange(aiColor4DVector values) {
AssimpPINVOKE.aiColor4DVector_AddRange(swigCPtr, aiColor4DVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiColor4DVector GetRange(int index, int count) {
IntPtr cPtr = AssimpPINVOKE.aiColor4DVector_GetRange(swigCPtr, index, count);
aiColor4DVector ret = (cPtr == IntPtr.Zero) ? null : new aiColor4DVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Insert(int index, SWIGTYPE_p_aiColor4D x) {
AssimpPINVOKE.aiColor4DVector_Insert(swigCPtr, index, SWIGTYPE_p_aiColor4D.getCPtr(x));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void InsertRange(int index, aiColor4DVector values) {
AssimpPINVOKE.aiColor4DVector_InsertRange(swigCPtr, index, aiColor4DVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveAt(int index) {
AssimpPINVOKE.aiColor4DVector_RemoveAt(swigCPtr, index);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveRange(int index, int count) {
AssimpPINVOKE.aiColor4DVector_RemoveRange(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public static aiColor4DVector Repeat(SWIGTYPE_p_aiColor4D value, int count) {
IntPtr cPtr = AssimpPINVOKE.aiColor4DVector_Repeat(SWIGTYPE_p_aiColor4D.getCPtr(value), count);
aiColor4DVector ret = (cPtr == IntPtr.Zero) ? null : new aiColor4DVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Reverse() {
AssimpPINVOKE.aiColor4DVector_Reverse__SWIG_0(swigCPtr);
}
public void Reverse(int index, int count) {
AssimpPINVOKE.aiColor4DVector_Reverse__SWIG_1(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void SetRange(int index, aiColor4DVector values) {
AssimpPINVOKE.aiColor4DVector_SetRange(swigCPtr, index, aiColor4DVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public bool Contains(SWIGTYPE_p_aiColor4D value) {
bool ret = AssimpPINVOKE.aiColor4DVector_Contains(swigCPtr, SWIGTYPE_p_aiColor4D.getCPtr(value));
return ret;
}
public int IndexOf(SWIGTYPE_p_aiColor4D value) {
int ret = AssimpPINVOKE.aiColor4DVector_IndexOf(swigCPtr, SWIGTYPE_p_aiColor4D.getCPtr(value));
return ret;
}
public int LastIndexOf(SWIGTYPE_p_aiColor4D value) {
int ret = AssimpPINVOKE.aiColor4DVector_LastIndexOf(swigCPtr, SWIGTYPE_p_aiColor4D.getCPtr(value));
return ret;
}
public bool Remove(SWIGTYPE_p_aiColor4D value) {
bool ret = AssimpPINVOKE.aiColor4DVector_Remove(swigCPtr, SWIGTYPE_p_aiColor4D.getCPtr(value));
return ret;
}
}

327
port/Assimp.NET/Assimp.NET_CS/aiColor4DVectorVector.cs
View File

@ -1,327 +0,0 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiColor4DVectorVector : IDisposable, System.Collections.IEnumerable
#if !SWIG_DOTNET_1
, System.Collections.Generic.IEnumerable<aiColor4DVector>
#endif
{
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiColor4DVectorVector(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiColor4DVectorVector obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiColor4DVectorVector() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
AssimpPINVOKE.delete_aiColor4DVectorVector(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiColor4DVectorVector(System.Collections.ICollection c) : this() {
if (c == null)
throw new ArgumentNullException("c");
foreach (aiColor4DVector element in c) {
this.Add(element);
}
}
public bool IsFixedSize {
get {
return false;
}
}
public bool IsReadOnly {
get {
return false;
}
}
public aiColor4DVector this[int index] {
get {
return getitem(index);
}
set {
setitem(index, value);
}
}
public int Capacity {
get {
return (int)capacity();
}
set {
if (value < size())
throw new ArgumentOutOfRangeException("Capacity");
reserve((uint)value);
}
}
public int Count {
get {
return (int)size();
}
}
public bool IsSynchronized {
get {
return false;
}
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array)
#else
public void CopyTo(aiColor4DVector[] array)
#endif
{
CopyTo(0, array, 0, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array, int arrayIndex)
#else
public void CopyTo(aiColor4DVector[] array, int arrayIndex)
#endif
{
CopyTo(0, array, arrayIndex, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(int index, System.Array array, int arrayIndex, int count)
#else
public void CopyTo(int index, aiColor4DVector[] array, int arrayIndex, int count)
#endif
{
if (array == null)
throw new ArgumentNullException("array");
if (index < 0)
throw new ArgumentOutOfRangeException("index", "Value is less than zero");
if (arrayIndex < 0)
throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
if (count < 0)
throw new ArgumentOutOfRangeException("count", "Value is less than zero");
if (array.Rank > 1)
throw new ArgumentException("Multi dimensional array.", "array");
if (index+count > this.Count || arrayIndex+count > array.Length)
throw new ArgumentException("Number of elements to copy is too large.");
for (int i=0; i<count; i++)
array.SetValue(getitemcopy(index+i), arrayIndex+i);
}
#if !SWIG_DOTNET_1
System.Collections.Generic.IEnumerator<aiColor4DVector> System.Collections.Generic.IEnumerable<aiColor4DVector>.GetEnumerator() {
return new aiColor4DVectorVectorEnumerator(this);
}
#endif
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
return new aiColor4DVectorVectorEnumerator(this);
}
public aiColor4DVectorVectorEnumerator GetEnumerator() {
return new aiColor4DVectorVectorEnumerator(this);
}
// Type-safe enumerator
/// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
/// whenever the collection is modified. This has been done for changes in the size of the
/// collection but not when one of the elements of the collection is modified as it is a bit
/// tricky to detect unmanaged code that modifies the collection under our feet.
public sealed class aiColor4DVectorVectorEnumerator : System.Collections.IEnumerator
#if !SWIG_DOTNET_1
, System.Collections.Generic.IEnumerator<aiColor4DVector>
#endif
{
private aiColor4DVectorVector collectionRef;
private int currentIndex;
private object currentObject;
private int currentSize;
public aiColor4DVectorVectorEnumerator(aiColor4DVectorVector collection) {
collectionRef = collection;
currentIndex = -1;
currentObject = null;
currentSize = collectionRef.Count;
}
// Type-safe iterator Current
public aiColor4DVector Current {
get {
if (currentIndex == -1)
throw new InvalidOperationException("Enumeration not started.");
if (currentIndex > currentSize - 1)
throw new InvalidOperationException("Enumeration finished.");
if (currentObject == null)
throw new InvalidOperationException("Collection modified.");
return (aiColor4DVector)currentObject;
}
}
// Type-unsafe IEnumerator.Current
object System.Collections.IEnumerator.Current {
get {
return Current;
}
}
public bool MoveNext() {
int size = collectionRef.Count;
bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
if (moveOkay) {
currentIndex++;
currentObject = collectionRef[currentIndex];
} else {
currentObject = null;
}
return moveOkay;
}
public void Reset() {
currentIndex = -1;
currentObject = null;
if (collectionRef.Count != currentSize) {
throw new InvalidOperationException("Collection modified.");
}
}
#if !SWIG_DOTNET_1
public void Dispose() {
currentIndex = -1;
currentObject = null;
}
#endif
}
public void Clear() {
AssimpPINVOKE.aiColor4DVectorVector_Clear(swigCPtr);
}
public void Add(aiColor4DVector x) {
AssimpPINVOKE.aiColor4DVectorVector_Add(swigCPtr, aiColor4DVector.getCPtr(x));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
private uint size() {
uint ret = AssimpPINVOKE.aiColor4DVectorVector_size(swigCPtr);
return ret;
}
private uint capacity() {
uint ret = AssimpPINVOKE.aiColor4DVectorVector_capacity(swigCPtr);
return ret;
}
private void reserve(uint n) {
AssimpPINVOKE.aiColor4DVectorVector_reserve(swigCPtr, n);
}
public aiColor4DVectorVector() : this(AssimpPINVOKE.new_aiColor4DVectorVector__SWIG_0(), true) {
}
public aiColor4DVectorVector(aiColor4DVectorVector other) : this(AssimpPINVOKE.new_aiColor4DVectorVector__SWIG_1(aiColor4DVectorVector.getCPtr(other)), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiColor4DVectorVector(int capacity) : this(AssimpPINVOKE.new_aiColor4DVectorVector__SWIG_2(capacity), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
private aiColor4DVector getitemcopy(int index) {
aiColor4DVector ret = new aiColor4DVector(AssimpPINVOKE.aiColor4DVectorVector_getitemcopy(swigCPtr, index), true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private aiColor4DVector getitem(int index) {
aiColor4DVector ret = new aiColor4DVector(AssimpPINVOKE.aiColor4DVectorVector_getitem(swigCPtr, index), false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private void setitem(int index, aiColor4DVector val) {
AssimpPINVOKE.aiColor4DVectorVector_setitem(swigCPtr, index, aiColor4DVector.getCPtr(val));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void AddRange(aiColor4DVectorVector values) {
AssimpPINVOKE.aiColor4DVectorVector_AddRange(swigCPtr, aiColor4DVectorVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiColor4DVectorVector GetRange(int index, int count) {
IntPtr cPtr = AssimpPINVOKE.aiColor4DVectorVector_GetRange(swigCPtr, index, count);
aiColor4DVectorVector ret = (cPtr == IntPtr.Zero) ? null : new aiColor4DVectorVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Insert(int index, aiColor4DVector x) {
AssimpPINVOKE.aiColor4DVectorVector_Insert(swigCPtr, index, aiColor4DVector.getCPtr(x));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void InsertRange(int index, aiColor4DVectorVector values) {
AssimpPINVOKE.aiColor4DVectorVector_InsertRange(swigCPtr, index, aiColor4DVectorVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveAt(int index) {
AssimpPINVOKE.aiColor4DVectorVector_RemoveAt(swigCPtr, index);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveRange(int index, int count) {
AssimpPINVOKE.aiColor4DVectorVector_RemoveRange(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public static aiColor4DVectorVector Repeat(aiColor4DVector value, int count) {
IntPtr cPtr = AssimpPINVOKE.aiColor4DVectorVector_Repeat(aiColor4DVector.getCPtr(value), count);
aiColor4DVectorVector ret = (cPtr == IntPtr.Zero) ? null : new aiColor4DVectorVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Reverse() {
AssimpPINVOKE.aiColor4DVectorVector_Reverse__SWIG_0(swigCPtr);
}
public void Reverse(int index, int count) {
AssimpPINVOKE.aiColor4DVectorVector_Reverse__SWIG_1(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void SetRange(int index, aiColor4DVectorVector values) {
AssimpPINVOKE.aiColor4DVectorVector_SetRange(swigCPtr, index, aiColor4DVectorVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
}

22
port/Assimp.NET/Assimp.NET_CS/aiComponent.cs 100644
View File

@ -0,0 +1,22 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
public enum aiComponent {
aiComponent_NORMALS = 0x2,
aiComponent_TANGENTS_AND_BITANGENTS = 0x4,
aiComponent_COLORS = 0x8,
aiComponent_TEXCOORDS = 0x10,
aiComponent_BONEWEIGHTS = 0x20,
aiComponent_ANIMATIONS = 0x40,
aiComponent_TEXTURES = 0x80,
aiComponent_LIGHTS = 0x100,
aiComponent_CAMERAS = 0x200,
aiComponent_MESHES = 0x400,
aiComponent_MATERIALS = 0x800
}

16
port/Assimp.NET/Assimp.NET_CS/aiDefaultLogStream.cs 100644
View File

@ -0,0 +1,16 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
public enum aiDefaultLogStream {
aiDefaultLogStream_FILE = 0x1,
aiDefaultLogStream_STDOUT = 0x2,
aiDefaultLogStream_STDERR = 0x4,
aiDefaultLogStream_DEBUGGER = 0x8,
_AI_DLS_ENFORCE_ENUM_SIZE = 0x7fffffff
}

89
port/Assimp.NET/Assimp.NET_CS/aiFace.cs 100644
View File

@ -0,0 +1,89 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiFace : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiFace(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiFace obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiFace() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiFace(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public uint mNumIndices {
set {
Assimp_NETPINVOKE.aiFace_mNumIndices_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiFace_mNumIndices_get(swigCPtr);
return ret;
}
}
public SWIGTYPE_p_unsigned_int mIndices {
set {
Assimp_NETPINVOKE.aiFace_mIndices_set(swigCPtr, SWIGTYPE_p_unsigned_int.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiFace_mIndices_get(swigCPtr);
SWIGTYPE_p_unsigned_int ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_int(cPtr, false);
return ret;
}
}
public aiFace() : this(Assimp_NETPINVOKE.new_aiFace__SWIG_0(), true) {
}
public aiFace(aiFace o) : this(Assimp_NETPINVOKE.new_aiFace__SWIG_1(aiFace.getCPtr(o)), true) {
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public aiFace __set__(aiFace o) {
aiFace ret = new aiFace(Assimp_NETPINVOKE.aiFace___set__(swigCPtr, aiFace.getCPtr(o)), false);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public bool __equal__(aiFace o) {
bool ret = Assimp_NETPINVOKE.aiFace___equal__(swigCPtr, aiFace.getCPtr(o));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public bool __nequal__(aiFace o) {
bool ret = Assimp_NETPINVOKE.aiFace___nequal__(swigCPtr, aiFace.getCPtr(o));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}

348
port/Assimp.NET/Assimp.NET_CS/aiFaceVector.cs
View File

@ -1,348 +0,0 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiFaceVector : IDisposable, System.Collections.IEnumerable
#if !SWIG_DOTNET_1
, System.Collections.Generic.IList<aiFace>
#endif
{
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiFaceVector(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiFaceVector obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiFaceVector() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
AssimpPINVOKE.delete_aiFaceVector(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiFaceVector(System.Collections.ICollection c) : this() {
if (c == null)
throw new ArgumentNullException("c");
foreach (aiFace element in c) {
this.Add(element);
}
}
public bool IsFixedSize {
get {
return false;
}
}
public bool IsReadOnly {
get {
return false;
}
}
public aiFace this[int index] {
get {
return getitem(index);
}
set {
setitem(index, value);
}
}
public int Capacity {
get {
return (int)capacity();
}
set {
if (value < size())
throw new ArgumentOutOfRangeException("Capacity");
reserve((uint)value);
}
}
public int Count {
get {
return (int)size();
}
}
public bool IsSynchronized {
get {
return false;
}
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array)
#else
public void CopyTo(aiFace[] array)
#endif
{
CopyTo(0, array, 0, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array, int arrayIndex)
#else
public void CopyTo(aiFace[] array, int arrayIndex)
#endif
{
CopyTo(0, array, arrayIndex, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(int index, System.Array array, int arrayIndex, int count)
#else
public void CopyTo(int index, aiFace[] array, int arrayIndex, int count)
#endif
{
if (array == null)
throw new ArgumentNullException("array");
if (index < 0)
throw new ArgumentOutOfRangeException("index", "Value is less than zero");
if (arrayIndex < 0)
throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
if (count < 0)
throw new ArgumentOutOfRangeException("count", "Value is less than zero");
if (array.Rank > 1)
throw new ArgumentException("Multi dimensional array.", "array");
if (index+count > this.Count || arrayIndex+count > array.Length)
throw new ArgumentException("Number of elements to copy is too large.");
for (int i=0; i<count; i++)
array.SetValue(getitemcopy(index+i), arrayIndex+i);
}
#if !SWIG_DOTNET_1
System.Collections.Generic.IEnumerator<aiFace> System.Collections.Generic.IEnumerable<aiFace>.GetEnumerator() {
return new aiFaceVectorEnumerator(this);
}
#endif
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
return new aiFaceVectorEnumerator(this);
}
public aiFaceVectorEnumerator GetEnumerator() {
return new aiFaceVectorEnumerator(this);
}
// Type-safe enumerator
/// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
/// whenever the collection is modified. This has been done for changes in the size of the
/// collection but not when one of the elements of the collection is modified as it is a bit
/// tricky to detect unmanaged code that modifies the collection under our feet.
public sealed class aiFaceVectorEnumerator : System.Collections.IEnumerator
#if !SWIG_DOTNET_1
, System.Collections.Generic.IEnumerator<aiFace>
#endif
{
private aiFaceVector collectionRef;
private int currentIndex;
private object currentObject;
private int currentSize;
public aiFaceVectorEnumerator(aiFaceVector collection) {
collectionRef = collection;
currentIndex = -1;
currentObject = null;
currentSize = collectionRef.Count;
}
// Type-safe iterator Current
public aiFace Current {
get {
if (currentIndex == -1)
throw new InvalidOperationException("Enumeration not started.");
if (currentIndex > currentSize - 1)
throw new InvalidOperationException("Enumeration finished.");
if (currentObject == null)
throw new InvalidOperationException("Collection modified.");
return (aiFace)currentObject;
}
}
// Type-unsafe IEnumerator.Current
object System.Collections.IEnumerator.Current {
get {
return Current;
}
}
public bool MoveNext() {
int size = collectionRef.Count;
bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
if (moveOkay) {
currentIndex++;
currentObject = collectionRef[currentIndex];
} else {
currentObject = null;
}
return moveOkay;
}
public void Reset() {
currentIndex = -1;
currentObject = null;
if (collectionRef.Count != currentSize) {
throw new InvalidOperationException("Collection modified.");
}
}
#if !SWIG_DOTNET_1
public void Dispose() {
currentIndex = -1;
currentObject = null;
}
#endif
}
public void Clear() {
AssimpPINVOKE.aiFaceVector_Clear(swigCPtr);
}
public void Add(aiFace x) {
AssimpPINVOKE.aiFaceVector_Add(swigCPtr, aiFace.getCPtr(x));
}
private uint size() {
uint ret = AssimpPINVOKE.aiFaceVector_size(swigCPtr);
return ret;
}
private uint capacity() {
uint ret = AssimpPINVOKE.aiFaceVector_capacity(swigCPtr);
return ret;
}
private void reserve(uint n) {
AssimpPINVOKE.aiFaceVector_reserve(swigCPtr, n);
}
public aiFaceVector() : this(AssimpPINVOKE.new_aiFaceVector__SWIG_0(), true) {
}
public aiFaceVector(aiFaceVector other) : this(AssimpPINVOKE.new_aiFaceVector__SWIG_1(aiFaceVector.getCPtr(other)), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiFaceVector(int capacity) : this(AssimpPINVOKE.new_aiFaceVector__SWIG_2(capacity), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
private aiFace getitemcopy(int index) {
IntPtr cPtr = AssimpPINVOKE.aiFaceVector_getitemcopy(swigCPtr, index);
aiFace ret = (cPtr == IntPtr.Zero) ? null : new aiFace(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private aiFace getitem(int index) {
IntPtr cPtr = AssimpPINVOKE.aiFaceVector_getitem(swigCPtr, index);
aiFace ret = (cPtr == IntPtr.Zero) ? null : new aiFace(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private void setitem(int index, aiFace val) {
AssimpPINVOKE.aiFaceVector_setitem(swigCPtr, index, aiFace.getCPtr(val));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void AddRange(aiFaceVector values) {
AssimpPINVOKE.aiFaceVector_AddRange(swigCPtr, aiFaceVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiFaceVector GetRange(int index, int count) {
IntPtr cPtr = AssimpPINVOKE.aiFaceVector_GetRange(swigCPtr, index, count);
aiFaceVector ret = (cPtr == IntPtr.Zero) ? null : new aiFaceVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Insert(int index, aiFace x) {
AssimpPINVOKE.aiFaceVector_Insert(swigCPtr, index, aiFace.getCPtr(x));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void InsertRange(int index, aiFaceVector values) {
AssimpPINVOKE.aiFaceVector_InsertRange(swigCPtr, index, aiFaceVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveAt(int index) {
AssimpPINVOKE.aiFaceVector_RemoveAt(swigCPtr, index);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveRange(int index, int count) {
AssimpPINVOKE.aiFaceVector_RemoveRange(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public static aiFaceVector Repeat(aiFace value, int count) {
IntPtr cPtr = AssimpPINVOKE.aiFaceVector_Repeat(aiFace.getCPtr(value), count);
aiFaceVector ret = (cPtr == IntPtr.Zero) ? null : new aiFaceVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Reverse() {
AssimpPINVOKE.aiFaceVector_Reverse__SWIG_0(swigCPtr);
}
public void Reverse(int index, int count) {
AssimpPINVOKE.aiFaceVector_Reverse__SWIG_1(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void SetRange(int index, aiFaceVector values) {
AssimpPINVOKE.aiFaceVector_SetRange(swigCPtr, index, aiFaceVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public bool Contains(aiFace value) {
bool ret = AssimpPINVOKE.aiFaceVector_Contains(swigCPtr, aiFace.getCPtr(value));
return ret;
}
public int IndexOf(aiFace value) {
int ret = AssimpPINVOKE.aiFaceVector_IndexOf(swigCPtr, aiFace.getCPtr(value));
return ret;
}
public int LastIndexOf(aiFace value) {
int ret = AssimpPINVOKE.aiFaceVector_LastIndexOf(swigCPtr, aiFace.getCPtr(value));
return ret;
}
public bool Remove(aiFace value) {
bool ret = AssimpPINVOKE.aiFaceVector_Remove(swigCPtr, aiFace.getCPtr(value));
return ret;
}
}

122
port/Assimp.NET/Assimp.NET_CS/aiFile.cs 100644
View File

@ -0,0 +1,122 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiFile : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiFile(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiFile obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiFile() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiFile(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public SWIGTYPE_p_f_p_aiFile_p_char_size_t_size_t__size_t ReadProc {
set {
Assimp_NETPINVOKE.aiFile_ReadProc_set(swigCPtr, SWIGTYPE_p_f_p_aiFile_p_char_size_t_size_t__size_t.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiFile_ReadProc_get(swigCPtr);
SWIGTYPE_p_f_p_aiFile_p_char_size_t_size_t__size_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_f_p_aiFile_p_char_size_t_size_t__size_t(cPtr, false);
return ret;
}
}
public SWIGTYPE_p_f_p_aiFile_p_q_const__char_size_t_size_t__size_t WriteProc {
set {
Assimp_NETPINVOKE.aiFile_WriteProc_set(swigCPtr, SWIGTYPE_p_f_p_aiFile_p_q_const__char_size_t_size_t__size_t.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiFile_WriteProc_get(swigCPtr);
SWIGTYPE_p_f_p_aiFile_p_q_const__char_size_t_size_t__size_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_f_p_aiFile_p_q_const__char_size_t_size_t__size_t(cPtr, false);
return ret;
}
}
public SWIGTYPE_p_f_p_aiFile__size_t TellProc {
set {
Assimp_NETPINVOKE.aiFile_TellProc_set(swigCPtr, SWIGTYPE_p_f_p_aiFile__size_t.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiFile_TellProc_get(swigCPtr);
SWIGTYPE_p_f_p_aiFile__size_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_f_p_aiFile__size_t(cPtr, false);
return ret;
}
}
public SWIGTYPE_p_f_p_aiFile__size_t FileSizeProc {
set {
Assimp_NETPINVOKE.aiFile_FileSizeProc_set(swigCPtr, SWIGTYPE_p_f_p_aiFile__size_t.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiFile_FileSizeProc_get(swigCPtr);
SWIGTYPE_p_f_p_aiFile__size_t ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_f_p_aiFile__size_t(cPtr, false);
return ret;
}
}
public SWIGTYPE_p_f_p_aiFile_size_t_enum_aiOrigin__aiReturn SeekProc {
set {
Assimp_NETPINVOKE.aiFile_SeekProc_set(swigCPtr, SWIGTYPE_p_f_p_aiFile_size_t_enum_aiOrigin__aiReturn.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiFile_SeekProc_get(swigCPtr);
SWIGTYPE_p_f_p_aiFile_size_t_enum_aiOrigin__aiReturn ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_f_p_aiFile_size_t_enum_aiOrigin__aiReturn(cPtr, false);
return ret;
}
}
public SWIGTYPE_p_f_p_aiFile__void FlushProc {
set {
Assimp_NETPINVOKE.aiFile_FlushProc_set(swigCPtr, SWIGTYPE_p_f_p_aiFile__void.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiFile_FlushProc_get(swigCPtr);
SWIGTYPE_p_f_p_aiFile__void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_f_p_aiFile__void(cPtr, false);
return ret;
}
}
public string UserData {
set {
Assimp_NETPINVOKE.aiFile_UserData_set(swigCPtr, value);
}
get {
string ret = Assimp_NETPINVOKE.aiFile_UserData_get(swigCPtr);
return ret;
}
}
public aiFile() : this(Assimp_NETPINVOKE.new_aiFile(), true) {
}
}

78
port/Assimp.NET/Assimp.NET_CS/aiFileIO.cs 100644
View File

@ -0,0 +1,78 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiFileIO : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiFileIO(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiFileIO obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiFileIO() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiFileIO(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public SWIGTYPE_p_f_p_aiFileIO_p_q_const__char_p_q_const__char__p_aiFile OpenProc {
set {
Assimp_NETPINVOKE.aiFileIO_OpenProc_set(swigCPtr, SWIGTYPE_p_f_p_aiFileIO_p_q_const__char_p_q_const__char__p_aiFile.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiFileIO_OpenProc_get(swigCPtr);
SWIGTYPE_p_f_p_aiFileIO_p_q_const__char_p_q_const__char__p_aiFile ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_f_p_aiFileIO_p_q_const__char_p_q_const__char__p_aiFile(cPtr, false);
return ret;
}
}
public SWIGTYPE_p_f_p_aiFileIO_p_aiFile__void CloseProc {
set {
Assimp_NETPINVOKE.aiFileIO_CloseProc_set(swigCPtr, SWIGTYPE_p_f_p_aiFileIO_p_aiFile__void.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiFileIO_CloseProc_get(swigCPtr);
SWIGTYPE_p_f_p_aiFileIO_p_aiFile__void ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_f_p_aiFileIO_p_aiFile__void(cPtr, false);
return ret;
}
}
public string UserData {
set {
Assimp_NETPINVOKE.aiFileIO_UserData_set(swigCPtr, value);
}
get {
string ret = Assimp_NETPINVOKE.aiFileIO_UserData_get(swigCPtr);
return ret;
}
}
public aiFileIO() : this(Assimp_NETPINVOKE.new_aiFileIO(), true) {
}
}

172
port/Assimp.NET/Assimp.NET_CS/aiLight.cs 100644
View File

@ -0,0 +1,172 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiLight : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiLight(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiLight obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiLight() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiLight(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiString mName {
set {
Assimp_NETPINVOKE.aiLight_mName_set(swigCPtr, aiString.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiLight_mName_get(swigCPtr);
aiString ret = (cPtr == IntPtr.Zero) ? null : new aiString(cPtr, false);
return ret;
}
}
public aiLightSourceType mType {
set {
Assimp_NETPINVOKE.aiLight_mType_set(swigCPtr, (int)value);
}
get {
aiLightSourceType ret = (aiLightSourceType)Assimp_NETPINVOKE.aiLight_mType_get(swigCPtr);
return ret;
}
}
public aiVector3D mPosition {
set {
Assimp_NETPINVOKE.aiLight_mPosition_set(swigCPtr, aiVector3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiLight_mPosition_get(swigCPtr);
aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
return ret;
}
}
public aiVector3D mDirection {
set {
Assimp_NETPINVOKE.aiLight_mDirection_set(swigCPtr, aiVector3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiLight_mDirection_get(swigCPtr);
aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
return ret;
}
}
public float mAttenuationConstant {
set {
Assimp_NETPINVOKE.aiLight_mAttenuationConstant_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiLight_mAttenuationConstant_get(swigCPtr);
return ret;
}
}
public float mAttenuationLinear {
set {
Assimp_NETPINVOKE.aiLight_mAttenuationLinear_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiLight_mAttenuationLinear_get(swigCPtr);
return ret;
}
}
public float mAttenuationQuadratic {
set {
Assimp_NETPINVOKE.aiLight_mAttenuationQuadratic_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiLight_mAttenuationQuadratic_get(swigCPtr);
return ret;
}
}
public aiColor3D mColorDiffuse {
set {
Assimp_NETPINVOKE.aiLight_mColorDiffuse_set(swigCPtr, aiColor3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiLight_mColorDiffuse_get(swigCPtr);
aiColor3D ret = (cPtr == IntPtr.Zero) ? null : new aiColor3D(cPtr, false);
return ret;
}
}
public aiColor3D mColorSpecular {
set {
Assimp_NETPINVOKE.aiLight_mColorSpecular_set(swigCPtr, aiColor3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiLight_mColorSpecular_get(swigCPtr);
aiColor3D ret = (cPtr == IntPtr.Zero) ? null : new aiColor3D(cPtr, false);
return ret;
}
}
public aiColor3D mColorAmbient {
set {
Assimp_NETPINVOKE.aiLight_mColorAmbient_set(swigCPtr, aiColor3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiLight_mColorAmbient_get(swigCPtr);
aiColor3D ret = (cPtr == IntPtr.Zero) ? null : new aiColor3D(cPtr, false);
return ret;
}
}
public float mAngleInnerCone {
set {
Assimp_NETPINVOKE.aiLight_mAngleInnerCone_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiLight_mAngleInnerCone_get(swigCPtr);
return ret;
}
}
public float mAngleOuterCone {
set {
Assimp_NETPINVOKE.aiLight_mAngleOuterCone_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiLight_mAngleOuterCone_get(swigCPtr);
return ret;
}
}
public aiLight() : this(Assimp_NETPINVOKE.new_aiLight(), true) {
}
}

15
port/Assimp.NET/Assimp.NET_CS/aiLightSourceType.cs 100644
View File

@ -0,0 +1,15 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
public enum aiLightSourceType {
aiLightSource_UNDEFINED = 0x0,
aiLightSource_DIRECTIONAL = 0x1,
aiLightSource_POINT = 0x2,
aiLightSource_SPOT = 0x3
}

348
port/Assimp.NET/Assimp.NET_CS/aiLightVector.cs
View File

@ -1,348 +0,0 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiLightVector : IDisposable, System.Collections.IEnumerable
#if !SWIG_DOTNET_1
, System.Collections.Generic.IList<aiLight>
#endif
{
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiLightVector(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiLightVector obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiLightVector() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
AssimpPINVOKE.delete_aiLightVector(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiLightVector(System.Collections.ICollection c) : this() {
if (c == null)
throw new ArgumentNullException("c");
foreach (aiLight element in c) {
this.Add(element);
}
}
public bool IsFixedSize {
get {
return false;
}
}
public bool IsReadOnly {
get {
return false;
}
}
public aiLight this[int index] {
get {
return getitem(index);
}
set {
setitem(index, value);
}
}
public int Capacity {
get {
return (int)capacity();
}
set {
if (value < size())
throw new ArgumentOutOfRangeException("Capacity");
reserve((uint)value);
}
}
public int Count {
get {
return (int)size();
}
}
public bool IsSynchronized {
get {
return false;
}
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array)
#else
public void CopyTo(aiLight[] array)
#endif
{
CopyTo(0, array, 0, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array, int arrayIndex)
#else
public void CopyTo(aiLight[] array, int arrayIndex)
#endif
{
CopyTo(0, array, arrayIndex, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(int index, System.Array array, int arrayIndex, int count)
#else
public void CopyTo(int index, aiLight[] array, int arrayIndex, int count)
#endif
{
if (array == null)
throw new ArgumentNullException("array");
if (index < 0)
throw new ArgumentOutOfRangeException("index", "Value is less than zero");
if (arrayIndex < 0)
throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
if (count < 0)
throw new ArgumentOutOfRangeException("count", "Value is less than zero");
if (array.Rank > 1)
throw new ArgumentException("Multi dimensional array.", "array");
if (index+count > this.Count || arrayIndex+count > array.Length)
throw new ArgumentException("Number of elements to copy is too large.");
for (int i=0; i<count; i++)
array.SetValue(getitemcopy(index+i), arrayIndex+i);
}
#if !SWIG_DOTNET_1
System.Collections.Generic.IEnumerator<aiLight> System.Collections.Generic.IEnumerable<aiLight>.GetEnumerator() {
return new aiLightVectorEnumerator(this);
}
#endif
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
return new aiLightVectorEnumerator(this);
}
public aiLightVectorEnumerator GetEnumerator() {
return new aiLightVectorEnumerator(this);
}
// Type-safe enumerator
/// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
/// whenever the collection is modified. This has been done for changes in the size of the
/// collection but not when one of the elements of the collection is modified as it is a bit
/// tricky to detect unmanaged code that modifies the collection under our feet.
public sealed class aiLightVectorEnumerator : System.Collections.IEnumerator
#if !SWIG_DOTNET_1
, System.Collections.Generic.IEnumerator<aiLight>
#endif
{
private aiLightVector collectionRef;
private int currentIndex;
private object currentObject;
private int currentSize;
public aiLightVectorEnumerator(aiLightVector collection) {
collectionRef = collection;
currentIndex = -1;
currentObject = null;
currentSize = collectionRef.Count;
}
// Type-safe iterator Current
public aiLight Current {
get {
if (currentIndex == -1)
throw new InvalidOperationException("Enumeration not started.");
if (currentIndex > currentSize - 1)
throw new InvalidOperationException("Enumeration finished.");
if (currentObject == null)
throw new InvalidOperationException("Collection modified.");
return (aiLight)currentObject;
}
}
// Type-unsafe IEnumerator.Current
object System.Collections.IEnumerator.Current {
get {
return Current;
}
}
public bool MoveNext() {
int size = collectionRef.Count;
bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
if (moveOkay) {
currentIndex++;
currentObject = collectionRef[currentIndex];
} else {
currentObject = null;
}
return moveOkay;
}
public void Reset() {
currentIndex = -1;
currentObject = null;
if (collectionRef.Count != currentSize) {
throw new InvalidOperationException("Collection modified.");
}
}
#if !SWIG_DOTNET_1
public void Dispose() {
currentIndex = -1;
currentObject = null;
}
#endif
}
public void Clear() {
AssimpPINVOKE.aiLightVector_Clear(swigCPtr);
}
public void Add(aiLight x) {
AssimpPINVOKE.aiLightVector_Add(swigCPtr, aiLight.getCPtr(x));
}
private uint size() {
uint ret = AssimpPINVOKE.aiLightVector_size(swigCPtr);
return ret;
}
private uint capacity() {
uint ret = AssimpPINVOKE.aiLightVector_capacity(swigCPtr);
return ret;
}
private void reserve(uint n) {
AssimpPINVOKE.aiLightVector_reserve(swigCPtr, n);
}
public aiLightVector() : this(AssimpPINVOKE.new_aiLightVector__SWIG_0(), true) {
}
public aiLightVector(aiLightVector other) : this(AssimpPINVOKE.new_aiLightVector__SWIG_1(aiLightVector.getCPtr(other)), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiLightVector(int capacity) : this(AssimpPINVOKE.new_aiLightVector__SWIG_2(capacity), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
private aiLight getitemcopy(int index) {
IntPtr cPtr = AssimpPINVOKE.aiLightVector_getitemcopy(swigCPtr, index);
aiLight ret = (cPtr == IntPtr.Zero) ? null : new aiLight(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private aiLight getitem(int index) {
IntPtr cPtr = AssimpPINVOKE.aiLightVector_getitem(swigCPtr, index);
aiLight ret = (cPtr == IntPtr.Zero) ? null : new aiLight(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private void setitem(int index, aiLight val) {
AssimpPINVOKE.aiLightVector_setitem(swigCPtr, index, aiLight.getCPtr(val));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void AddRange(aiLightVector values) {
AssimpPINVOKE.aiLightVector_AddRange(swigCPtr, aiLightVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiLightVector GetRange(int index, int count) {
IntPtr cPtr = AssimpPINVOKE.aiLightVector_GetRange(swigCPtr, index, count);
aiLightVector ret = (cPtr == IntPtr.Zero) ? null : new aiLightVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Insert(int index, aiLight x) {
AssimpPINVOKE.aiLightVector_Insert(swigCPtr, index, aiLight.getCPtr(x));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void InsertRange(int index, aiLightVector values) {
AssimpPINVOKE.aiLightVector_InsertRange(swigCPtr, index, aiLightVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveAt(int index) {
AssimpPINVOKE.aiLightVector_RemoveAt(swigCPtr, index);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveRange(int index, int count) {
AssimpPINVOKE.aiLightVector_RemoveRange(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public static aiLightVector Repeat(aiLight value, int count) {
IntPtr cPtr = AssimpPINVOKE.aiLightVector_Repeat(aiLight.getCPtr(value), count);
aiLightVector ret = (cPtr == IntPtr.Zero) ? null : new aiLightVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Reverse() {
AssimpPINVOKE.aiLightVector_Reverse__SWIG_0(swigCPtr);
}
public void Reverse(int index, int count) {
AssimpPINVOKE.aiLightVector_Reverse__SWIG_1(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void SetRange(int index, aiLightVector values) {
AssimpPINVOKE.aiLightVector_SetRange(swigCPtr, index, aiLightVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public bool Contains(aiLight value) {
bool ret = AssimpPINVOKE.aiLightVector_Contains(swigCPtr, aiLight.getCPtr(value));
return ret;
}
public int IndexOf(aiLight value) {
int ret = AssimpPINVOKE.aiLightVector_IndexOf(swigCPtr, aiLight.getCPtr(value));
return ret;
}
public int LastIndexOf(aiLight value) {
int ret = AssimpPINVOKE.aiLightVector_LastIndexOf(swigCPtr, aiLight.getCPtr(value));
return ret;
}
public bool Remove(aiLight value) {
bool ret = AssimpPINVOKE.aiLightVector_Remove(swigCPtr, aiLight.getCPtr(value));
return ret;
}
}

112
port/Assimp.NET/Assimp.NET_CS/aiMaterial.cs 100644
View File

@ -0,0 +1,112 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiMaterial : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiMaterial(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiMaterial obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiMaterial() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiMaterial(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiMaterial() : this(Assimp_NETPINVOKE.new_aiMaterial(), true) {
}
public uint GetTextureCount(aiTextureType type) {
uint ret = Assimp_NETPINVOKE.aiMaterial_GetTextureCount(swigCPtr, (int)type);
return ret;
}
public aiReturn GetTexture(aiTextureType type, uint index, aiString path, SWIGTYPE_p_aiTextureMapping mapping, SWIGTYPE_p_unsigned_int uvindex, SWIGTYPE_p_float blend, SWIGTYPE_p_aiTextureOp op, SWIGTYPE_p_aiTextureMapMode mapmode) {
aiReturn ret = (aiReturn)Assimp_NETPINVOKE.aiMaterial_GetTexture__SWIG_0(swigCPtr, (int)type, index, aiString.getCPtr(path), SWIGTYPE_p_aiTextureMapping.getCPtr(mapping), SWIGTYPE_p_unsigned_int.getCPtr(uvindex), SWIGTYPE_p_float.getCPtr(blend), SWIGTYPE_p_aiTextureOp.getCPtr(op), SWIGTYPE_p_aiTextureMapMode.getCPtr(mapmode));
return ret;
}
public aiReturn GetTexture(aiTextureType type, uint index, aiString path, SWIGTYPE_p_aiTextureMapping mapping, SWIGTYPE_p_unsigned_int uvindex, SWIGTYPE_p_float blend, SWIGTYPE_p_aiTextureOp op) {
aiReturn ret = (aiReturn)Assimp_NETPINVOKE.aiMaterial_GetTexture__SWIG_1(swigCPtr, (int)type, index, aiString.getCPtr(path), SWIGTYPE_p_aiTextureMapping.getCPtr(mapping), SWIGTYPE_p_unsigned_int.getCPtr(uvindex), SWIGTYPE_p_float.getCPtr(blend), SWIGTYPE_p_aiTextureOp.getCPtr(op));
return ret;
}
public aiReturn GetTexture(aiTextureType type, uint index, aiString path, SWIGTYPE_p_aiTextureMapping mapping, SWIGTYPE_p_unsigned_int uvindex, SWIGTYPE_p_float blend) {
aiReturn ret = (aiReturn)Assimp_NETPINVOKE.aiMaterial_GetTexture__SWIG_2(swigCPtr, (int)type, index, aiString.getCPtr(path), SWIGTYPE_p_aiTextureMapping.getCPtr(mapping), SWIGTYPE_p_unsigned_int.getCPtr(uvindex), SWIGTYPE_p_float.getCPtr(blend));
return ret;
}
public aiReturn GetTexture(aiTextureType type, uint index, aiString path, SWIGTYPE_p_aiTextureMapping mapping, SWIGTYPE_p_unsigned_int uvindex) {
aiReturn ret = (aiReturn)Assimp_NETPINVOKE.aiMaterial_GetTexture__SWIG_3(swigCPtr, (int)type, index, aiString.getCPtr(path), SWIGTYPE_p_aiTextureMapping.getCPtr(mapping), SWIGTYPE_p_unsigned_int.getCPtr(uvindex));
return ret;
}
public aiReturn GetTexture(aiTextureType type, uint index, aiString path, SWIGTYPE_p_aiTextureMapping mapping) {
aiReturn ret = (aiReturn)Assimp_NETPINVOKE.aiMaterial_GetTexture__SWIG_4(swigCPtr, (int)type, index, aiString.getCPtr(path), SWIGTYPE_p_aiTextureMapping.getCPtr(mapping));
return ret;
}
public aiReturn GetTexture(aiTextureType type, uint index, aiString path) {
aiReturn ret = (aiReturn)Assimp_NETPINVOKE.aiMaterial_GetTexture__SWIG_5(swigCPtr, (int)type, index, aiString.getCPtr(path));
return ret;
}
public SWIGTYPE_p_p_aiMaterialProperty mProperties {
set {
Assimp_NETPINVOKE.aiMaterial_mProperties_set(swigCPtr, SWIGTYPE_p_p_aiMaterialProperty.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiMaterial_mProperties_get(swigCPtr);
SWIGTYPE_p_p_aiMaterialProperty ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_p_aiMaterialProperty(cPtr, false);
return ret;
}
}
public uint mNumProperties {
set {
Assimp_NETPINVOKE.aiMaterial_mNumProperties_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMaterial_mNumProperties_get(swigCPtr);
return ret;
}
}
public uint mNumAllocated {
set {
Assimp_NETPINVOKE.aiMaterial_mNumAllocated_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMaterial_mNumAllocated_get(swigCPtr);
return ret;
}
}
}

107
port/Assimp.NET/Assimp.NET_CS/aiMaterialProperty.cs 100644
View File

@ -0,0 +1,107 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiMaterialProperty : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiMaterialProperty(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiMaterialProperty obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiMaterialProperty() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiMaterialProperty(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiString mKey {
set {
Assimp_NETPINVOKE.aiMaterialProperty_mKey_set(swigCPtr, aiString.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiMaterialProperty_mKey_get(swigCPtr);
aiString ret = (cPtr == IntPtr.Zero) ? null : new aiString(cPtr, false);
return ret;
}
}
public uint mSemantic {
set {
Assimp_NETPINVOKE.aiMaterialProperty_mSemantic_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMaterialProperty_mSemantic_get(swigCPtr);
return ret;
}
}
public uint mIndex {
set {
Assimp_NETPINVOKE.aiMaterialProperty_mIndex_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMaterialProperty_mIndex_get(swigCPtr);
return ret;
}
}
public uint mDataLength {
set {
Assimp_NETPINVOKE.aiMaterialProperty_mDataLength_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMaterialProperty_mDataLength_get(swigCPtr);
return ret;
}
}
public aiPropertyTypeInfo mType {
set {
Assimp_NETPINVOKE.aiMaterialProperty_mType_set(swigCPtr, (int)value);
}
get {
aiPropertyTypeInfo ret = (aiPropertyTypeInfo)Assimp_NETPINVOKE.aiMaterialProperty_mType_get(swigCPtr);
return ret;
}
}
public string mData {
set {
Assimp_NETPINVOKE.aiMaterialProperty_mData_set(swigCPtr, value);
}
get {
string ret = Assimp_NETPINVOKE.aiMaterialProperty_mData_get(swigCPtr);
return ret;
}
}
public aiMaterialProperty() : this(Assimp_NETPINVOKE.new_aiMaterialProperty(), true) {
}
}

348
port/Assimp.NET/Assimp.NET_CS/aiMaterialVector.cs
View File

@ -1,348 +0,0 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiMaterialVector : IDisposable, System.Collections.IEnumerable
#if !SWIG_DOTNET_1
, System.Collections.Generic.IList<aiMaterial>
#endif
{
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiMaterialVector(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiMaterialVector obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiMaterialVector() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
AssimpPINVOKE.delete_aiMaterialVector(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiMaterialVector(System.Collections.ICollection c) : this() {
if (c == null)
throw new ArgumentNullException("c");
foreach (aiMaterial element in c) {
this.Add(element);
}
}
public bool IsFixedSize {
get {
return false;
}
}
public bool IsReadOnly {
get {
return false;
}
}
public aiMaterial this[int index] {
get {
return getitem(index);
}
set {
setitem(index, value);
}
}
public int Capacity {
get {
return (int)capacity();
}
set {
if (value < size())
throw new ArgumentOutOfRangeException("Capacity");
reserve((uint)value);
}
}
public int Count {
get {
return (int)size();
}
}
public bool IsSynchronized {
get {
return false;
}
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array)
#else
public void CopyTo(aiMaterial[] array)
#endif
{
CopyTo(0, array, 0, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array, int arrayIndex)
#else
public void CopyTo(aiMaterial[] array, int arrayIndex)
#endif
{
CopyTo(0, array, arrayIndex, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(int index, System.Array array, int arrayIndex, int count)
#else
public void CopyTo(int index, aiMaterial[] array, int arrayIndex, int count)
#endif
{
if (array == null)
throw new ArgumentNullException("array");
if (index < 0)
throw new ArgumentOutOfRangeException("index", "Value is less than zero");
if (arrayIndex < 0)
throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
if (count < 0)
throw new ArgumentOutOfRangeException("count", "Value is less than zero");
if (array.Rank > 1)
throw new ArgumentException("Multi dimensional array.", "array");
if (index+count > this.Count || arrayIndex+count > array.Length)
throw new ArgumentException("Number of elements to copy is too large.");
for (int i=0; i<count; i++)
array.SetValue(getitemcopy(index+i), arrayIndex+i);
}
#if !SWIG_DOTNET_1
System.Collections.Generic.IEnumerator<aiMaterial> System.Collections.Generic.IEnumerable<aiMaterial>.GetEnumerator() {
return new aiMaterialVectorEnumerator(this);
}
#endif
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
return new aiMaterialVectorEnumerator(this);
}
public aiMaterialVectorEnumerator GetEnumerator() {
return new aiMaterialVectorEnumerator(this);
}
// Type-safe enumerator
/// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
/// whenever the collection is modified. This has been done for changes in the size of the
/// collection but not when one of the elements of the collection is modified as it is a bit
/// tricky to detect unmanaged code that modifies the collection under our feet.
public sealed class aiMaterialVectorEnumerator : System.Collections.IEnumerator
#if !SWIG_DOTNET_1
, System.Collections.Generic.IEnumerator<aiMaterial>
#endif
{
private aiMaterialVector collectionRef;
private int currentIndex;
private object currentObject;
private int currentSize;
public aiMaterialVectorEnumerator(aiMaterialVector collection) {
collectionRef = collection;
currentIndex = -1;
currentObject = null;
currentSize = collectionRef.Count;
}
// Type-safe iterator Current
public aiMaterial Current {
get {
if (currentIndex == -1)
throw new InvalidOperationException("Enumeration not started.");
if (currentIndex > currentSize - 1)
throw new InvalidOperationException("Enumeration finished.");
if (currentObject == null)
throw new InvalidOperationException("Collection modified.");
return (aiMaterial)currentObject;
}
}
// Type-unsafe IEnumerator.Current
object System.Collections.IEnumerator.Current {
get {
return Current;
}
}
public bool MoveNext() {
int size = collectionRef.Count;
bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
if (moveOkay) {
currentIndex++;
currentObject = collectionRef[currentIndex];
} else {
currentObject = null;
}
return moveOkay;
}
public void Reset() {
currentIndex = -1;
currentObject = null;
if (collectionRef.Count != currentSize) {
throw new InvalidOperationException("Collection modified.");
}
}
#if !SWIG_DOTNET_1
public void Dispose() {
currentIndex = -1;
currentObject = null;
}
#endif
}
public void Clear() {
AssimpPINVOKE.aiMaterialVector_Clear(swigCPtr);
}
public void Add(aiMaterial x) {
AssimpPINVOKE.aiMaterialVector_Add(swigCPtr, aiMaterial.getCPtr(x));
}
private uint size() {
uint ret = AssimpPINVOKE.aiMaterialVector_size(swigCPtr);
return ret;
}
private uint capacity() {
uint ret = AssimpPINVOKE.aiMaterialVector_capacity(swigCPtr);
return ret;
}
private void reserve(uint n) {
AssimpPINVOKE.aiMaterialVector_reserve(swigCPtr, n);
}
public aiMaterialVector() : this(AssimpPINVOKE.new_aiMaterialVector__SWIG_0(), true) {
}
public aiMaterialVector(aiMaterialVector other) : this(AssimpPINVOKE.new_aiMaterialVector__SWIG_1(aiMaterialVector.getCPtr(other)), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiMaterialVector(int capacity) : this(AssimpPINVOKE.new_aiMaterialVector__SWIG_2(capacity), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
private aiMaterial getitemcopy(int index) {
IntPtr cPtr = AssimpPINVOKE.aiMaterialVector_getitemcopy(swigCPtr, index);
aiMaterial ret = (cPtr == IntPtr.Zero) ? null : new aiMaterial(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private aiMaterial getitem(int index) {
IntPtr cPtr = AssimpPINVOKE.aiMaterialVector_getitem(swigCPtr, index);
aiMaterial ret = (cPtr == IntPtr.Zero) ? null : new aiMaterial(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private void setitem(int index, aiMaterial val) {
AssimpPINVOKE.aiMaterialVector_setitem(swigCPtr, index, aiMaterial.getCPtr(val));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void AddRange(aiMaterialVector values) {
AssimpPINVOKE.aiMaterialVector_AddRange(swigCPtr, aiMaterialVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiMaterialVector GetRange(int index, int count) {
IntPtr cPtr = AssimpPINVOKE.aiMaterialVector_GetRange(swigCPtr, index, count);
aiMaterialVector ret = (cPtr == IntPtr.Zero) ? null : new aiMaterialVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Insert(int index, aiMaterial x) {
AssimpPINVOKE.aiMaterialVector_Insert(swigCPtr, index, aiMaterial.getCPtr(x));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void InsertRange(int index, aiMaterialVector values) {
AssimpPINVOKE.aiMaterialVector_InsertRange(swigCPtr, index, aiMaterialVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveAt(int index) {
AssimpPINVOKE.aiMaterialVector_RemoveAt(swigCPtr, index);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveRange(int index, int count) {
AssimpPINVOKE.aiMaterialVector_RemoveRange(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public static aiMaterialVector Repeat(aiMaterial value, int count) {
IntPtr cPtr = AssimpPINVOKE.aiMaterialVector_Repeat(aiMaterial.getCPtr(value), count);
aiMaterialVector ret = (cPtr == IntPtr.Zero) ? null : new aiMaterialVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Reverse() {
AssimpPINVOKE.aiMaterialVector_Reverse__SWIG_0(swigCPtr);
}
public void Reverse(int index, int count) {
AssimpPINVOKE.aiMaterialVector_Reverse__SWIG_1(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void SetRange(int index, aiMaterialVector values) {
AssimpPINVOKE.aiMaterialVector_SetRange(swigCPtr, index, aiMaterialVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public bool Contains(aiMaterial value) {
bool ret = AssimpPINVOKE.aiMaterialVector_Contains(swigCPtr, aiMaterial.getCPtr(value));
return ret;
}
public int IndexOf(aiMaterial value) {
int ret = AssimpPINVOKE.aiMaterialVector_IndexOf(swigCPtr, aiMaterial.getCPtr(value));
return ret;
}
public int LastIndexOf(aiMaterial value) {
int ret = AssimpPINVOKE.aiMaterialVector_LastIndexOf(swigCPtr, aiMaterial.getCPtr(value));
return ret;
}
public bool Remove(aiMaterial value) {
bool ret = AssimpPINVOKE.aiMaterialVector_Remove(swigCPtr, aiMaterial.getCPtr(value));
return ret;
}
}

212
port/Assimp.NET/Assimp.NET_CS/aiMatrix3x3.cs 100644
View File

@ -0,0 +1,212 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiMatrix3x3 : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiMatrix3x3(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiMatrix3x3 obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiMatrix3x3() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiMatrix3x3(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiMatrix3x3() : this(Assimp_NETPINVOKE.new_aiMatrix3x3__SWIG_0(), true) {
}
public aiMatrix3x3(float _a1, float _a2, float _a3, float _b1, float _b2, float _b3, float _c1, float _c2, float _c3) : this(Assimp_NETPINVOKE.new_aiMatrix3x3__SWIG_1(_a1, _a2, _a3, _b1, _b2, _b3, _c1, _c2, _c3), true) {
}
public aiMatrix3x3 __mulnset__(aiMatrix3x3 m) {
aiMatrix3x3 ret = new aiMatrix3x3(Assimp_NETPINVOKE.aiMatrix3x3___mulnset__(swigCPtr, aiMatrix3x3.getCPtr(m)), false);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public aiMatrix3x3 __mul__(aiMatrix3x3 m) {
aiMatrix3x3 ret = new aiMatrix3x3(Assimp_NETPINVOKE.aiMatrix3x3___mul__(swigCPtr, aiMatrix3x3.getCPtr(m)), true);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public SWIGTYPE_p_float __idx__(uint p_iIndex) {
IntPtr cPtr = Assimp_NETPINVOKE.aiMatrix3x3___idx____SWIG_0(swigCPtr, p_iIndex);
SWIGTYPE_p_float ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_float(cPtr, false);
return ret;
}
public bool __equal__(aiMatrix4x4 m) {
bool ret = Assimp_NETPINVOKE.aiMatrix3x3___equal__(swigCPtr, aiMatrix4x4.getCPtr(m));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public bool __nequal__(aiMatrix4x4 m) {
bool ret = Assimp_NETPINVOKE.aiMatrix3x3___nequal__(swigCPtr, aiMatrix4x4.getCPtr(m));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public aiMatrix3x3(aiMatrix4x4 pMatrix) : this(Assimp_NETPINVOKE.new_aiMatrix3x3__SWIG_2(aiMatrix4x4.getCPtr(pMatrix)), true) {
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public aiMatrix3x3 Transpose() {
aiMatrix3x3 ret = new aiMatrix3x3(Assimp_NETPINVOKE.aiMatrix3x3_Transpose(swigCPtr), false);
return ret;
}
public aiMatrix3x3 Inverse() {
aiMatrix3x3 ret = new aiMatrix3x3(Assimp_NETPINVOKE.aiMatrix3x3_Inverse(swigCPtr), false);
return ret;
}
public float Determinant() {
float ret = Assimp_NETPINVOKE.aiMatrix3x3_Determinant(swigCPtr);
return ret;
}
public static aiMatrix3x3 RotationZ(float a, aiMatrix3x3 arg1) {
aiMatrix3x3 ret = new aiMatrix3x3(Assimp_NETPINVOKE.aiMatrix3x3_RotationZ(a, aiMatrix3x3.getCPtr(arg1)), false);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static aiMatrix3x3 Rotation(float a, aiVector3D axis, aiMatrix3x3 arg2) {
aiMatrix3x3 ret = new aiMatrix3x3(Assimp_NETPINVOKE.aiMatrix3x3_Rotation(a, aiVector3D.getCPtr(axis), aiMatrix3x3.getCPtr(arg2)), false);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static aiMatrix3x3 Translation(aiVector2D v, aiMatrix3x3 arg1) {
aiMatrix3x3 ret = new aiMatrix3x3(Assimp_NETPINVOKE.aiMatrix3x3_Translation(aiVector2D.getCPtr(v), aiMatrix3x3.getCPtr(arg1)), false);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static aiMatrix3x3 FromToMatrix(aiVector3D from, aiVector3D to, aiMatrix3x3 arg2) {
aiMatrix3x3 ret = new aiMatrix3x3(Assimp_NETPINVOKE.aiMatrix3x3_FromToMatrix(aiVector3D.getCPtr(from), aiVector3D.getCPtr(to), aiMatrix3x3.getCPtr(arg2)), false);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public float a1 {
set {
Assimp_NETPINVOKE.aiMatrix3x3_a1_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix3x3_a1_get(swigCPtr);
return ret;
}
}
public float a2 {
set {
Assimp_NETPINVOKE.aiMatrix3x3_a2_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix3x3_a2_get(swigCPtr);
return ret;
}
}
public float a3 {
set {
Assimp_NETPINVOKE.aiMatrix3x3_a3_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix3x3_a3_get(swigCPtr);
return ret;
}
}
public float b1 {
set {
Assimp_NETPINVOKE.aiMatrix3x3_b1_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix3x3_b1_get(swigCPtr);
return ret;
}
}
public float b2 {
set {
Assimp_NETPINVOKE.aiMatrix3x3_b2_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix3x3_b2_get(swigCPtr);
return ret;
}
}
public float b3 {
set {
Assimp_NETPINVOKE.aiMatrix3x3_b3_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix3x3_b3_get(swigCPtr);
return ret;
}
}
public float c1 {
set {
Assimp_NETPINVOKE.aiMatrix3x3_c1_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix3x3_c1_get(swigCPtr);
return ret;
}
}
public float c2 {
set {
Assimp_NETPINVOKE.aiMatrix3x3_c2_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix3x3_c2_get(swigCPtr);
return ret;
}
}
public float c3 {
set {
Assimp_NETPINVOKE.aiMatrix3x3_c3_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix3x3_c3_get(swigCPtr);
return ret;
}
}
}

326
port/Assimp.NET/Assimp.NET_CS/aiMatrix4x4.cs 100644
View File

@ -0,0 +1,326 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiMatrix4x4 : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiMatrix4x4(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiMatrix4x4 obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiMatrix4x4() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiMatrix4x4(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiMatrix4x4() : this(Assimp_NETPINVOKE.new_aiMatrix4x4__SWIG_0(), true) {
}
public aiMatrix4x4(float _a1, float _a2, float _a3, float _a4, float _b1, float _b2, float _b3, float _b4, float _c1, float _c2, float _c3, float _c4, float _d1, float _d2, float _d3, float _d4) : this(Assimp_NETPINVOKE.new_aiMatrix4x4__SWIG_1(_a1, _a2, _a3, _a4, _b1, _b2, _b3, _b4, _c1, _c2, _c3, _c4, _d1, _d2, _d3, _d4), true) {
}
public aiMatrix4x4(aiMatrix3x3 m) : this(Assimp_NETPINVOKE.new_aiMatrix4x4__SWIG_2(aiMatrix3x3.getCPtr(m)), true) {
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public SWIGTYPE_p_float __idx__(uint p_iIndex) {
IntPtr cPtr = Assimp_NETPINVOKE.aiMatrix4x4___idx____SWIG_0(swigCPtr, p_iIndex);
SWIGTYPE_p_float ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_float(cPtr, false);
return ret;
}
public bool __equal__(aiMatrix4x4 m) {
bool ret = Assimp_NETPINVOKE.aiMatrix4x4___equal__(swigCPtr, aiMatrix4x4.getCPtr(m));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public bool __nequal__(aiMatrix4x4 m) {
bool ret = Assimp_NETPINVOKE.aiMatrix4x4___nequal__(swigCPtr, aiMatrix4x4.getCPtr(m));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public aiMatrix4x4 __mulnset__(aiMatrix4x4 m) {
aiMatrix4x4 ret = new aiMatrix4x4(Assimp_NETPINVOKE.aiMatrix4x4___mulnset__(swigCPtr, aiMatrix4x4.getCPtr(m)), false);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public aiMatrix4x4 __mul__(aiMatrix4x4 m) {
aiMatrix4x4 ret = new aiMatrix4x4(Assimp_NETPINVOKE.aiMatrix4x4___mul__(swigCPtr, aiMatrix4x4.getCPtr(m)), true);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public aiMatrix4x4 Transpose() {
aiMatrix4x4 ret = new aiMatrix4x4(Assimp_NETPINVOKE.aiMatrix4x4_Transpose(swigCPtr), false);
return ret;
}
public aiMatrix4x4 Inverse() {
aiMatrix4x4 ret = new aiMatrix4x4(Assimp_NETPINVOKE.aiMatrix4x4_Inverse(swigCPtr), false);
return ret;
}
public float Determinant() {
float ret = Assimp_NETPINVOKE.aiMatrix4x4_Determinant(swigCPtr);
return ret;
}
public bool IsIdentity() {
bool ret = Assimp_NETPINVOKE.aiMatrix4x4_IsIdentity(swigCPtr);
return ret;
}
public void Decompose(aiVector3D scaling, aiQuaternion rotation, aiVector3D position) {
Assimp_NETPINVOKE.aiMatrix4x4_Decompose(swigCPtr, aiVector3D.getCPtr(scaling), aiQuaternion.getCPtr(rotation), aiVector3D.getCPtr(position));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public void DecomposeNoScaling(aiQuaternion rotation, aiVector3D position) {
Assimp_NETPINVOKE.aiMatrix4x4_DecomposeNoScaling(swigCPtr, aiQuaternion.getCPtr(rotation), aiVector3D.getCPtr(position));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public aiMatrix4x4 FromEulerAnglesXYZ(float x, float y, float z) {
aiMatrix4x4 ret = new aiMatrix4x4(Assimp_NETPINVOKE.aiMatrix4x4_FromEulerAnglesXYZ__SWIG_0(swigCPtr, x, y, z), false);
return ret;
}
public aiMatrix4x4 FromEulerAnglesXYZ(aiVector3D blubb) {
aiMatrix4x4 ret = new aiMatrix4x4(Assimp_NETPINVOKE.aiMatrix4x4_FromEulerAnglesXYZ__SWIG_1(swigCPtr, aiVector3D.getCPtr(blubb)), false);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static aiMatrix4x4 RotationX(float a, aiMatrix4x4 arg1) {
aiMatrix4x4 ret = new aiMatrix4x4(Assimp_NETPINVOKE.aiMatrix4x4_RotationX(a, aiMatrix4x4.getCPtr(arg1)), false);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static aiMatrix4x4 RotationY(float a, aiMatrix4x4 arg1) {
aiMatrix4x4 ret = new aiMatrix4x4(Assimp_NETPINVOKE.aiMatrix4x4_RotationY(a, aiMatrix4x4.getCPtr(arg1)), false);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static aiMatrix4x4 RotationZ(float a, aiMatrix4x4 arg1) {
aiMatrix4x4 ret = new aiMatrix4x4(Assimp_NETPINVOKE.aiMatrix4x4_RotationZ(a, aiMatrix4x4.getCPtr(arg1)), false);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static aiMatrix4x4 Rotation(float a, aiVector3D axis, aiMatrix4x4 arg2) {
aiMatrix4x4 ret = new aiMatrix4x4(Assimp_NETPINVOKE.aiMatrix4x4_Rotation(a, aiVector3D.getCPtr(axis), aiMatrix4x4.getCPtr(arg2)), false);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static aiMatrix4x4 Translation(aiVector3D v, aiMatrix4x4 arg1) {
aiMatrix4x4 ret = new aiMatrix4x4(Assimp_NETPINVOKE.aiMatrix4x4_Translation(aiVector3D.getCPtr(v), aiMatrix4x4.getCPtr(arg1)), false);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static aiMatrix4x4 Scaling(aiVector3D v, aiMatrix4x4 arg1) {
aiMatrix4x4 ret = new aiMatrix4x4(Assimp_NETPINVOKE.aiMatrix4x4_Scaling(aiVector3D.getCPtr(v), aiMatrix4x4.getCPtr(arg1)), false);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static aiMatrix4x4 FromToMatrix(aiVector3D from, aiVector3D to, aiMatrix4x4 arg2) {
aiMatrix4x4 ret = new aiMatrix4x4(Assimp_NETPINVOKE.aiMatrix4x4_FromToMatrix(aiVector3D.getCPtr(from), aiVector3D.getCPtr(to), aiMatrix4x4.getCPtr(arg2)), false);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public float a1 {
set {
Assimp_NETPINVOKE.aiMatrix4x4_a1_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix4x4_a1_get(swigCPtr);
return ret;
}
}
public float a2 {
set {
Assimp_NETPINVOKE.aiMatrix4x4_a2_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix4x4_a2_get(swigCPtr);
return ret;
}
}
public float a3 {
set {
Assimp_NETPINVOKE.aiMatrix4x4_a3_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix4x4_a3_get(swigCPtr);
return ret;
}
}
public float a4 {
set {
Assimp_NETPINVOKE.aiMatrix4x4_a4_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix4x4_a4_get(swigCPtr);
return ret;
}
}
public float b1 {
set {
Assimp_NETPINVOKE.aiMatrix4x4_b1_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix4x4_b1_get(swigCPtr);
return ret;
}
}
public float b2 {
set {
Assimp_NETPINVOKE.aiMatrix4x4_b2_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix4x4_b2_get(swigCPtr);
return ret;
}
}
public float b3 {
set {
Assimp_NETPINVOKE.aiMatrix4x4_b3_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix4x4_b3_get(swigCPtr);
return ret;
}
}
public float b4 {
set {
Assimp_NETPINVOKE.aiMatrix4x4_b4_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix4x4_b4_get(swigCPtr);
return ret;
}
}
public float c1 {
set {
Assimp_NETPINVOKE.aiMatrix4x4_c1_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix4x4_c1_get(swigCPtr);
return ret;
}
}
public float c2 {
set {
Assimp_NETPINVOKE.aiMatrix4x4_c2_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix4x4_c2_get(swigCPtr);
return ret;
}
}
public float c3 {
set {
Assimp_NETPINVOKE.aiMatrix4x4_c3_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix4x4_c3_get(swigCPtr);
return ret;
}
}
public float c4 {
set {
Assimp_NETPINVOKE.aiMatrix4x4_c4_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix4x4_c4_get(swigCPtr);
return ret;
}
}
public float d1 {
set {
Assimp_NETPINVOKE.aiMatrix4x4_d1_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix4x4_d1_get(swigCPtr);
return ret;
}
}
public float d2 {
set {
Assimp_NETPINVOKE.aiMatrix4x4_d2_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix4x4_d2_get(swigCPtr);
return ret;
}
}
public float d3 {
set {
Assimp_NETPINVOKE.aiMatrix4x4_d3_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix4x4_d3_get(swigCPtr);
return ret;
}
}
public float d4 {
set {
Assimp_NETPINVOKE.aiMatrix4x4_d4_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiMatrix4x4_d4_get(swigCPtr);
return ret;
}
}
}

126
port/Assimp.NET/Assimp.NET_CS/aiMemoryInfo.cs 100644
View File

@ -0,0 +1,126 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiMemoryInfo : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiMemoryInfo(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiMemoryInfo obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiMemoryInfo() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiMemoryInfo(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiMemoryInfo() : this(Assimp_NETPINVOKE.new_aiMemoryInfo(), true) {
}
public uint textures {
set {
Assimp_NETPINVOKE.aiMemoryInfo_textures_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMemoryInfo_textures_get(swigCPtr);
return ret;
}
}
public uint materials {
set {
Assimp_NETPINVOKE.aiMemoryInfo_materials_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMemoryInfo_materials_get(swigCPtr);
return ret;
}
}
public uint meshes {
set {
Assimp_NETPINVOKE.aiMemoryInfo_meshes_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMemoryInfo_meshes_get(swigCPtr);
return ret;
}
}
public uint nodes {
set {
Assimp_NETPINVOKE.aiMemoryInfo_nodes_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMemoryInfo_nodes_get(swigCPtr);
return ret;
}
}
public uint animations {
set {
Assimp_NETPINVOKE.aiMemoryInfo_animations_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMemoryInfo_animations_get(swigCPtr);
return ret;
}
}
public uint cameras {
set {
Assimp_NETPINVOKE.aiMemoryInfo_cameras_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMemoryInfo_cameras_get(swigCPtr);
return ret;
}
}
public uint lights {
set {
Assimp_NETPINVOKE.aiMemoryInfo_lights_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMemoryInfo_lights_get(swigCPtr);
return ret;
}
}
public uint total {
set {
Assimp_NETPINVOKE.aiMemoryInfo_total_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMemoryInfo_total_get(swigCPtr);
return ret;
}
}
}

272
port/Assimp.NET/Assimp.NET_CS/aiMesh.cs 100644
View File

@ -0,0 +1,272 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiMesh : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiMesh(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiMesh obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiMesh() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiMesh(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public uint mPrimitiveTypes {
set {
Assimp_NETPINVOKE.aiMesh_mPrimitiveTypes_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMesh_mPrimitiveTypes_get(swigCPtr);
return ret;
}
}
public uint mNumVertices {
set {
Assimp_NETPINVOKE.aiMesh_mNumVertices_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMesh_mNumVertices_get(swigCPtr);
return ret;
}
}
public uint mNumFaces {
set {
Assimp_NETPINVOKE.aiMesh_mNumFaces_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMesh_mNumFaces_get(swigCPtr);
return ret;
}
}
public aiVector3D mVertices {
set {
Assimp_NETPINVOKE.aiMesh_mVertices_set(swigCPtr, aiVector3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiMesh_mVertices_get(swigCPtr);
aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
return ret;
}
}
public aiVector3D mNormals {
set {
Assimp_NETPINVOKE.aiMesh_mNormals_set(swigCPtr, aiVector3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiMesh_mNormals_get(swigCPtr);
aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
return ret;
}
}
public aiVector3D mTangents {
set {
Assimp_NETPINVOKE.aiMesh_mTangents_set(swigCPtr, aiVector3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiMesh_mTangents_get(swigCPtr);
aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
return ret;
}
}
public aiVector3D mBitangents {
set {
Assimp_NETPINVOKE.aiMesh_mBitangents_set(swigCPtr, aiVector3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiMesh_mBitangents_get(swigCPtr);
aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
return ret;
}
}
public SWIGTYPE_p_p_aiColor4D mColors {
set {
Assimp_NETPINVOKE.aiMesh_mColors_set(swigCPtr, SWIGTYPE_p_p_aiColor4D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiMesh_mColors_get(swigCPtr);
SWIGTYPE_p_p_aiColor4D ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_p_aiColor4D(cPtr, false);
return ret;
}
}
public SWIGTYPE_p_p_aiVector3D mTextureCoords {
set {
Assimp_NETPINVOKE.aiMesh_mTextureCoords_set(swigCPtr, SWIGTYPE_p_p_aiVector3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiMesh_mTextureCoords_get(swigCPtr);
SWIGTYPE_p_p_aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_p_aiVector3D(cPtr, false);
return ret;
}
}
public SWIGTYPE_p_unsigned_int mNumUVComponents {
set {
Assimp_NETPINVOKE.aiMesh_mNumUVComponents_set(swigCPtr, SWIGTYPE_p_unsigned_int.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiMesh_mNumUVComponents_get(swigCPtr);
SWIGTYPE_p_unsigned_int ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_int(cPtr, false);
return ret;
}
}
public aiFace mFaces {
set {
Assimp_NETPINVOKE.aiMesh_mFaces_set(swigCPtr, aiFace.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiMesh_mFaces_get(swigCPtr);
aiFace ret = (cPtr == IntPtr.Zero) ? null : new aiFace(cPtr, false);
return ret;
}
}
public uint mNumBones {
set {
Assimp_NETPINVOKE.aiMesh_mNumBones_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMesh_mNumBones_get(swigCPtr);
return ret;
}
}
public SWIGTYPE_p_p_aiBone mBones {
set {
Assimp_NETPINVOKE.aiMesh_mBones_set(swigCPtr, SWIGTYPE_p_p_aiBone.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiMesh_mBones_get(swigCPtr);
SWIGTYPE_p_p_aiBone ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_p_aiBone(cPtr, false);
return ret;
}
}
public uint mMaterialIndex {
set {
Assimp_NETPINVOKE.aiMesh_mMaterialIndex_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMesh_mMaterialIndex_get(swigCPtr);
return ret;
}
}
public aiString mName {
set {
Assimp_NETPINVOKE.aiMesh_mName_set(swigCPtr, aiString.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiMesh_mName_get(swigCPtr);
aiString ret = (cPtr == IntPtr.Zero) ? null : new aiString(cPtr, false);
return ret;
}
}
public uint mNumAnimMeshes {
set {
Assimp_NETPINVOKE.aiMesh_mNumAnimMeshes_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMesh_mNumAnimMeshes_get(swigCPtr);
return ret;
}
}
public SWIGTYPE_p_p_aiAnimMesh mAnimMeshes {
set {
Assimp_NETPINVOKE.aiMesh_mAnimMeshes_set(swigCPtr, SWIGTYPE_p_p_aiAnimMesh.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiMesh_mAnimMeshes_get(swigCPtr);
SWIGTYPE_p_p_aiAnimMesh ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_p_aiAnimMesh(cPtr, false);
return ret;
}
}
public aiMesh() : this(Assimp_NETPINVOKE.new_aiMesh(), true) {
}
public bool HasPositions() {
bool ret = Assimp_NETPINVOKE.aiMesh_HasPositions(swigCPtr);
return ret;
}
public bool HasFaces() {
bool ret = Assimp_NETPINVOKE.aiMesh_HasFaces(swigCPtr);
return ret;
}
public bool HasNormals() {
bool ret = Assimp_NETPINVOKE.aiMesh_HasNormals(swigCPtr);
return ret;
}
public bool HasTangentsAndBitangents() {
bool ret = Assimp_NETPINVOKE.aiMesh_HasTangentsAndBitangents(swigCPtr);
return ret;
}
public bool HasVertexColors(uint pIndex) {
bool ret = Assimp_NETPINVOKE.aiMesh_HasVertexColors(swigCPtr, pIndex);
return ret;
}
public bool HasTextureCoords(uint pIndex) {
bool ret = Assimp_NETPINVOKE.aiMesh_HasTextureCoords(swigCPtr, pIndex);
return ret;
}
public uint GetNumUVChannels() {
uint ret = Assimp_NETPINVOKE.aiMesh_GetNumUVChannels(swigCPtr);
return ret;
}
public uint GetNumColorChannels() {
uint ret = Assimp_NETPINVOKE.aiMesh_GetNumColorChannels(swigCPtr);
return ret;
}
public bool HasBones() {
bool ret = Assimp_NETPINVOKE.aiMesh_HasBones(swigCPtr);
return ret;
}
}

78
port/Assimp.NET/Assimp.NET_CS/aiMeshAnim.cs 100644
View File

@ -0,0 +1,78 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiMeshAnim : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiMeshAnim(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiMeshAnim obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiMeshAnim() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiMeshAnim(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiString mName {
set {
Assimp_NETPINVOKE.aiMeshAnim_mName_set(swigCPtr, aiString.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiMeshAnim_mName_get(swigCPtr);
aiString ret = (cPtr == IntPtr.Zero) ? null : new aiString(cPtr, false);
return ret;
}
}
public uint mNumKeys {
set {
Assimp_NETPINVOKE.aiMeshAnim_mNumKeys_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMeshAnim_mNumKeys_get(swigCPtr);
return ret;
}
}
public aiMeshKey mKeys {
set {
Assimp_NETPINVOKE.aiMeshAnim_mKeys_set(swigCPtr, aiMeshKey.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiMeshAnim_mKeys_get(swigCPtr);
aiMeshKey ret = (cPtr == IntPtr.Zero) ? null : new aiMeshKey(cPtr, false);
return ret;
}
}
public aiMeshAnim() : this(Assimp_NETPINVOKE.new_aiMeshAnim(), true) {
}
}

93
port/Assimp.NET/Assimp.NET_CS/aiMeshKey.cs 100644
View File

@ -0,0 +1,93 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiMeshKey : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiMeshKey(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiMeshKey obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiMeshKey() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiMeshKey(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public double mTime {
set {
Assimp_NETPINVOKE.aiMeshKey_mTime_set(swigCPtr, value);
}
get {
double ret = Assimp_NETPINVOKE.aiMeshKey_mTime_get(swigCPtr);
return ret;
}
}
public uint mValue {
set {
Assimp_NETPINVOKE.aiMeshKey_mValue_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiMeshKey_mValue_get(swigCPtr);
return ret;
}
}
public aiMeshKey() : this(Assimp_NETPINVOKE.new_aiMeshKey__SWIG_0(), true) {
}
public aiMeshKey(double time, uint value) : this(Assimp_NETPINVOKE.new_aiMeshKey__SWIG_1(time, value), true) {
}
public bool __equal__(aiMeshKey o) {
bool ret = Assimp_NETPINVOKE.aiMeshKey___equal__(swigCPtr, aiMeshKey.getCPtr(o));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public bool __nequal__(aiMeshKey o) {
bool ret = Assimp_NETPINVOKE.aiMeshKey___nequal__(swigCPtr, aiMeshKey.getCPtr(o));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public bool __smaller__(aiMeshKey o) {
bool ret = Assimp_NETPINVOKE.aiMeshKey___smaller__(swigCPtr, aiMeshKey.getCPtr(o));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public bool __greater__(aiMeshKey o) {
bool ret = Assimp_NETPINVOKE.aiMeshKey___greater__(swigCPtr, aiMeshKey.getCPtr(o));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}

348
port/Assimp.NET/Assimp.NET_CS/aiMeshVector.cs
View File

@ -1,348 +0,0 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiMeshVector : IDisposable, System.Collections.IEnumerable
#if !SWIG_DOTNET_1
, System.Collections.Generic.IList<aiMesh>
#endif
{
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiMeshVector(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiMeshVector obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiMeshVector() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
AssimpPINVOKE.delete_aiMeshVector(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiMeshVector(System.Collections.ICollection c) : this() {
if (c == null)
throw new ArgumentNullException("c");
foreach (aiMesh element in c) {
this.Add(element);
}
}
public bool IsFixedSize {
get {
return false;
}
}
public bool IsReadOnly {
get {
return false;
}
}
public aiMesh this[int index] {
get {
return getitem(index);
}
set {
setitem(index, value);
}
}
public int Capacity {
get {
return (int)capacity();
}
set {
if (value < size())
throw new ArgumentOutOfRangeException("Capacity");
reserve((uint)value);
}
}
public int Count {
get {
return (int)size();
}
}
public bool IsSynchronized {
get {
return false;
}
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array)
#else
public void CopyTo(aiMesh[] array)
#endif
{
CopyTo(0, array, 0, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array, int arrayIndex)
#else
public void CopyTo(aiMesh[] array, int arrayIndex)
#endif
{
CopyTo(0, array, arrayIndex, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(int index, System.Array array, int arrayIndex, int count)
#else
public void CopyTo(int index, aiMesh[] array, int arrayIndex, int count)
#endif
{
if (array == null)
throw new ArgumentNullException("array");
if (index < 0)
throw new ArgumentOutOfRangeException("index", "Value is less than zero");
if (arrayIndex < 0)
throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
if (count < 0)
throw new ArgumentOutOfRangeException("count", "Value is less than zero");
if (array.Rank > 1)
throw new ArgumentException("Multi dimensional array.", "array");
if (index+count > this.Count || arrayIndex+count > array.Length)
throw new ArgumentException("Number of elements to copy is too large.");
for (int i=0; i<count; i++)
array.SetValue(getitemcopy(index+i), arrayIndex+i);
}
#if !SWIG_DOTNET_1
System.Collections.Generic.IEnumerator<aiMesh> System.Collections.Generic.IEnumerable<aiMesh>.GetEnumerator() {
return new aiMeshVectorEnumerator(this);
}
#endif
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
return new aiMeshVectorEnumerator(this);
}
public aiMeshVectorEnumerator GetEnumerator() {
return new aiMeshVectorEnumerator(this);
}
// Type-safe enumerator
/// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
/// whenever the collection is modified. This has been done for changes in the size of the
/// collection but not when one of the elements of the collection is modified as it is a bit
/// tricky to detect unmanaged code that modifies the collection under our feet.
public sealed class aiMeshVectorEnumerator : System.Collections.IEnumerator
#if !SWIG_DOTNET_1
, System.Collections.Generic.IEnumerator<aiMesh>
#endif
{
private aiMeshVector collectionRef;
private int currentIndex;
private object currentObject;
private int currentSize;
public aiMeshVectorEnumerator(aiMeshVector collection) {
collectionRef = collection;
currentIndex = -1;
currentObject = null;
currentSize = collectionRef.Count;
}
// Type-safe iterator Current
public aiMesh Current {
get {
if (currentIndex == -1)
throw new InvalidOperationException("Enumeration not started.");
if (currentIndex > currentSize - 1)
throw new InvalidOperationException("Enumeration finished.");
if (currentObject == null)
throw new InvalidOperationException("Collection modified.");
return (aiMesh)currentObject;
}
}
// Type-unsafe IEnumerator.Current
object System.Collections.IEnumerator.Current {
get {
return Current;
}
}
public bool MoveNext() {
int size = collectionRef.Count;
bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
if (moveOkay) {
currentIndex++;
currentObject = collectionRef[currentIndex];
} else {
currentObject = null;
}
return moveOkay;
}
public void Reset() {
currentIndex = -1;
currentObject = null;
if (collectionRef.Count != currentSize) {
throw new InvalidOperationException("Collection modified.");
}
}
#if !SWIG_DOTNET_1
public void Dispose() {
currentIndex = -1;
currentObject = null;
}
#endif
}
public void Clear() {
AssimpPINVOKE.aiMeshVector_Clear(swigCPtr);
}
public void Add(aiMesh x) {
AssimpPINVOKE.aiMeshVector_Add(swigCPtr, aiMesh.getCPtr(x));
}
private uint size() {
uint ret = AssimpPINVOKE.aiMeshVector_size(swigCPtr);
return ret;
}
private uint capacity() {
uint ret = AssimpPINVOKE.aiMeshVector_capacity(swigCPtr);
return ret;
}
private void reserve(uint n) {
AssimpPINVOKE.aiMeshVector_reserve(swigCPtr, n);
}
public aiMeshVector() : this(AssimpPINVOKE.new_aiMeshVector__SWIG_0(), true) {
}
public aiMeshVector(aiMeshVector other) : this(AssimpPINVOKE.new_aiMeshVector__SWIG_1(aiMeshVector.getCPtr(other)), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiMeshVector(int capacity) : this(AssimpPINVOKE.new_aiMeshVector__SWIG_2(capacity), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
private aiMesh getitemcopy(int index) {
IntPtr cPtr = AssimpPINVOKE.aiMeshVector_getitemcopy(swigCPtr, index);
aiMesh ret = (cPtr == IntPtr.Zero) ? null : new aiMesh(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private aiMesh getitem(int index) {
IntPtr cPtr = AssimpPINVOKE.aiMeshVector_getitem(swigCPtr, index);
aiMesh ret = (cPtr == IntPtr.Zero) ? null : new aiMesh(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private void setitem(int index, aiMesh val) {
AssimpPINVOKE.aiMeshVector_setitem(swigCPtr, index, aiMesh.getCPtr(val));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void AddRange(aiMeshVector values) {
AssimpPINVOKE.aiMeshVector_AddRange(swigCPtr, aiMeshVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiMeshVector GetRange(int index, int count) {
IntPtr cPtr = AssimpPINVOKE.aiMeshVector_GetRange(swigCPtr, index, count);
aiMeshVector ret = (cPtr == IntPtr.Zero) ? null : new aiMeshVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Insert(int index, aiMesh x) {
AssimpPINVOKE.aiMeshVector_Insert(swigCPtr, index, aiMesh.getCPtr(x));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void InsertRange(int index, aiMeshVector values) {
AssimpPINVOKE.aiMeshVector_InsertRange(swigCPtr, index, aiMeshVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveAt(int index) {
AssimpPINVOKE.aiMeshVector_RemoveAt(swigCPtr, index);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveRange(int index, int count) {
AssimpPINVOKE.aiMeshVector_RemoveRange(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public static aiMeshVector Repeat(aiMesh value, int count) {
IntPtr cPtr = AssimpPINVOKE.aiMeshVector_Repeat(aiMesh.getCPtr(value), count);
aiMeshVector ret = (cPtr == IntPtr.Zero) ? null : new aiMeshVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Reverse() {
AssimpPINVOKE.aiMeshVector_Reverse__SWIG_0(swigCPtr);
}
public void Reverse(int index, int count) {
AssimpPINVOKE.aiMeshVector_Reverse__SWIG_1(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void SetRange(int index, aiMeshVector values) {
AssimpPINVOKE.aiMeshVector_SetRange(swigCPtr, index, aiMeshVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public bool Contains(aiMesh value) {
bool ret = AssimpPINVOKE.aiMeshVector_Contains(swigCPtr, aiMesh.getCPtr(value));
return ret;
}
public int IndexOf(aiMesh value) {
int ret = AssimpPINVOKE.aiMeshVector_IndexOf(swigCPtr, aiMesh.getCPtr(value));
return ret;
}
public int LastIndexOf(aiMesh value) {
int ret = AssimpPINVOKE.aiMeshVector_LastIndexOf(swigCPtr, aiMesh.getCPtr(value));
return ret;
}
public bool Remove(aiMesh value) {
bool ret = AssimpPINVOKE.aiMeshVector_Remove(swigCPtr, aiMesh.getCPtr(value));
return ret;
}
}

138
port/Assimp.NET/Assimp.NET_CS/aiNode.cs 100644
View File

@ -0,0 +1,138 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiNode : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiNode(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiNode obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiNode() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiNode(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiString mName {
set {
Assimp_NETPINVOKE.aiNode_mName_set(swigCPtr, aiString.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiNode_mName_get(swigCPtr);
aiString ret = (cPtr == IntPtr.Zero) ? null : new aiString(cPtr, false);
return ret;
}
}
public aiMatrix4x4 mTransformation {
set {
Assimp_NETPINVOKE.aiNode_mTransformation_set(swigCPtr, aiMatrix4x4.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiNode_mTransformation_get(swigCPtr);
aiMatrix4x4 ret = (cPtr == IntPtr.Zero) ? null : new aiMatrix4x4(cPtr, false);
return ret;
}
}
public aiNode mParent {
set {
Assimp_NETPINVOKE.aiNode_mParent_set(swigCPtr, aiNode.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiNode_mParent_get(swigCPtr);
aiNode ret = (cPtr == IntPtr.Zero) ? null : new aiNode(cPtr, false);
return ret;
}
}
public uint mNumChildren {
set {
Assimp_NETPINVOKE.aiNode_mNumChildren_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiNode_mNumChildren_get(swigCPtr);
return ret;
}
}
public SWIGTYPE_p_p_aiNode mChildren {
set {
Assimp_NETPINVOKE.aiNode_mChildren_set(swigCPtr, SWIGTYPE_p_p_aiNode.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiNode_mChildren_get(swigCPtr);
SWIGTYPE_p_p_aiNode ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_p_aiNode(cPtr, false);
return ret;
}
}
public uint mNumMeshes {
set {
Assimp_NETPINVOKE.aiNode_mNumMeshes_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiNode_mNumMeshes_get(swigCPtr);
return ret;
}
}
public SWIGTYPE_p_unsigned_int mMeshes {
set {
Assimp_NETPINVOKE.aiNode_mMeshes_set(swigCPtr, SWIGTYPE_p_unsigned_int.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiNode_mMeshes_get(swigCPtr);
SWIGTYPE_p_unsigned_int ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_int(cPtr, false);
return ret;
}
}
public aiNode() : this(Assimp_NETPINVOKE.new_aiNode__SWIG_0(), true) {
}
public aiNode(string name) : this(Assimp_NETPINVOKE.new_aiNode__SWIG_1(name), true) {
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public aiNode FindNode(aiString name) {
IntPtr cPtr = Assimp_NETPINVOKE.aiNode_FindNode__SWIG_0(swigCPtr, aiString.getCPtr(name));
aiNode ret = (cPtr == IntPtr.Zero) ? null : new aiNode(cPtr, false);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public aiNode FindNode(string name) {
IntPtr cPtr = Assimp_NETPINVOKE.aiNode_FindNode__SWIG_1(swigCPtr, name);
aiNode ret = (cPtr == IntPtr.Zero) ? null : new aiNode(cPtr, false);
return ret;
}
}

140
port/Assimp.NET/Assimp.NET_CS/aiNodeAnim.cs 100644
View File

@ -0,0 +1,140 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiNodeAnim : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiNodeAnim(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiNodeAnim obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiNodeAnim() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiNodeAnim(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiString mNodeName {
set {
Assimp_NETPINVOKE.aiNodeAnim_mNodeName_set(swigCPtr, aiString.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiNodeAnim_mNodeName_get(swigCPtr);
aiString ret = (cPtr == IntPtr.Zero) ? null : new aiString(cPtr, false);
return ret;
}
}
public uint mNumPositionKeys {
set {
Assimp_NETPINVOKE.aiNodeAnim_mNumPositionKeys_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiNodeAnim_mNumPositionKeys_get(swigCPtr);
return ret;
}
}
public aiVectorKey mPositionKeys {
set {
Assimp_NETPINVOKE.aiNodeAnim_mPositionKeys_set(swigCPtr, aiVectorKey.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiNodeAnim_mPositionKeys_get(swigCPtr);
aiVectorKey ret = (cPtr == IntPtr.Zero) ? null : new aiVectorKey(cPtr, false);
return ret;
}
}
public uint mNumRotationKeys {
set {
Assimp_NETPINVOKE.aiNodeAnim_mNumRotationKeys_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiNodeAnim_mNumRotationKeys_get(swigCPtr);
return ret;
}
}
public aiQuatKey mRotationKeys {
set {
Assimp_NETPINVOKE.aiNodeAnim_mRotationKeys_set(swigCPtr, aiQuatKey.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiNodeAnim_mRotationKeys_get(swigCPtr);
aiQuatKey ret = (cPtr == IntPtr.Zero) ? null : new aiQuatKey(cPtr, false);
return ret;
}
}
public uint mNumScalingKeys {
set {
Assimp_NETPINVOKE.aiNodeAnim_mNumScalingKeys_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiNodeAnim_mNumScalingKeys_get(swigCPtr);
return ret;
}
}
public aiVectorKey mScalingKeys {
set {
Assimp_NETPINVOKE.aiNodeAnim_mScalingKeys_set(swigCPtr, aiVectorKey.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiNodeAnim_mScalingKeys_get(swigCPtr);
aiVectorKey ret = (cPtr == IntPtr.Zero) ? null : new aiVectorKey(cPtr, false);
return ret;
}
}
public aiAnimBehaviour mPreState {
set {
Assimp_NETPINVOKE.aiNodeAnim_mPreState_set(swigCPtr, (int)value);
}
get {
aiAnimBehaviour ret = (aiAnimBehaviour)Assimp_NETPINVOKE.aiNodeAnim_mPreState_get(swigCPtr);
return ret;
}
}
public aiAnimBehaviour mPostState {
set {
Assimp_NETPINVOKE.aiNodeAnim_mPostState_set(swigCPtr, (int)value);
}
get {
aiAnimBehaviour ret = (aiAnimBehaviour)Assimp_NETPINVOKE.aiNodeAnim_mPostState_get(swigCPtr);
return ret;
}
}
public aiNodeAnim() : this(Assimp_NETPINVOKE.new_aiNodeAnim(), true) {
}
}

348
port/Assimp.NET/Assimp.NET_CS/aiNodeAnimVector.cs
View File

@ -1,348 +0,0 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiNodeAnimVector : IDisposable, System.Collections.IEnumerable
#if !SWIG_DOTNET_1
, System.Collections.Generic.IList<aiNodeAnim>
#endif
{
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiNodeAnimVector(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiNodeAnimVector obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiNodeAnimVector() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
AssimpPINVOKE.delete_aiNodeAnimVector(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiNodeAnimVector(System.Collections.ICollection c) : this() {
if (c == null)
throw new ArgumentNullException("c");
foreach (aiNodeAnim element in c) {
this.Add(element);
}
}
public bool IsFixedSize {
get {
return false;
}
}
public bool IsReadOnly {
get {
return false;
}
}
public aiNodeAnim this[int index] {
get {
return getitem(index);
}
set {
setitem(index, value);
}
}
public int Capacity {
get {
return (int)capacity();
}
set {
if (value < size())
throw new ArgumentOutOfRangeException("Capacity");
reserve((uint)value);
}
}
public int Count {
get {
return (int)size();
}
}
public bool IsSynchronized {
get {
return false;
}
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array)
#else
public void CopyTo(aiNodeAnim[] array)
#endif
{
CopyTo(0, array, 0, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array, int arrayIndex)
#else
public void CopyTo(aiNodeAnim[] array, int arrayIndex)
#endif
{
CopyTo(0, array, arrayIndex, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(int index, System.Array array, int arrayIndex, int count)
#else
public void CopyTo(int index, aiNodeAnim[] array, int arrayIndex, int count)
#endif
{
if (array == null)
throw new ArgumentNullException("array");
if (index < 0)
throw new ArgumentOutOfRangeException("index", "Value is less than zero");
if (arrayIndex < 0)
throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
if (count < 0)
throw new ArgumentOutOfRangeException("count", "Value is less than zero");
if (array.Rank > 1)
throw new ArgumentException("Multi dimensional array.", "array");
if (index+count > this.Count || arrayIndex+count > array.Length)
throw new ArgumentException("Number of elements to copy is too large.");
for (int i=0; i<count; i++)
array.SetValue(getitemcopy(index+i), arrayIndex+i);
}
#if !SWIG_DOTNET_1
System.Collections.Generic.IEnumerator<aiNodeAnim> System.Collections.Generic.IEnumerable<aiNodeAnim>.GetEnumerator() {
return new aiNodeAnimVectorEnumerator(this);
}
#endif
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
return new aiNodeAnimVectorEnumerator(this);
}
public aiNodeAnimVectorEnumerator GetEnumerator() {
return new aiNodeAnimVectorEnumerator(this);
}
// Type-safe enumerator
/// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
/// whenever the collection is modified. This has been done for changes in the size of the
/// collection but not when one of the elements of the collection is modified as it is a bit
/// tricky to detect unmanaged code that modifies the collection under our feet.
public sealed class aiNodeAnimVectorEnumerator : System.Collections.IEnumerator
#if !SWIG_DOTNET_1
, System.Collections.Generic.IEnumerator<aiNodeAnim>
#endif
{
private aiNodeAnimVector collectionRef;
private int currentIndex;
private object currentObject;
private int currentSize;
public aiNodeAnimVectorEnumerator(aiNodeAnimVector collection) {
collectionRef = collection;
currentIndex = -1;
currentObject = null;
currentSize = collectionRef.Count;
}
// Type-safe iterator Current
public aiNodeAnim Current {
get {
if (currentIndex == -1)
throw new InvalidOperationException("Enumeration not started.");
if (currentIndex > currentSize - 1)
throw new InvalidOperationException("Enumeration finished.");
if (currentObject == null)
throw new InvalidOperationException("Collection modified.");
return (aiNodeAnim)currentObject;
}
}
// Type-unsafe IEnumerator.Current
object System.Collections.IEnumerator.Current {
get {
return Current;
}
}
public bool MoveNext() {
int size = collectionRef.Count;
bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
if (moveOkay) {
currentIndex++;
currentObject = collectionRef[currentIndex];
} else {
currentObject = null;
}
return moveOkay;
}
public void Reset() {
currentIndex = -1;
currentObject = null;
if (collectionRef.Count != currentSize) {
throw new InvalidOperationException("Collection modified.");
}
}
#if !SWIG_DOTNET_1
public void Dispose() {
currentIndex = -1;
currentObject = null;
}
#endif
}
public void Clear() {
AssimpPINVOKE.aiNodeAnimVector_Clear(swigCPtr);
}
public void Add(aiNodeAnim x) {
AssimpPINVOKE.aiNodeAnimVector_Add(swigCPtr, aiNodeAnim.getCPtr(x));
}
private uint size() {
uint ret = AssimpPINVOKE.aiNodeAnimVector_size(swigCPtr);
return ret;
}
private uint capacity() {
uint ret = AssimpPINVOKE.aiNodeAnimVector_capacity(swigCPtr);
return ret;
}
private void reserve(uint n) {
AssimpPINVOKE.aiNodeAnimVector_reserve(swigCPtr, n);
}
public aiNodeAnimVector() : this(AssimpPINVOKE.new_aiNodeAnimVector__SWIG_0(), true) {
}
public aiNodeAnimVector(aiNodeAnimVector other) : this(AssimpPINVOKE.new_aiNodeAnimVector__SWIG_1(aiNodeAnimVector.getCPtr(other)), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiNodeAnimVector(int capacity) : this(AssimpPINVOKE.new_aiNodeAnimVector__SWIG_2(capacity), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
private aiNodeAnim getitemcopy(int index) {
IntPtr cPtr = AssimpPINVOKE.aiNodeAnimVector_getitemcopy(swigCPtr, index);
aiNodeAnim ret = (cPtr == IntPtr.Zero) ? null : new aiNodeAnim(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private aiNodeAnim getitem(int index) {
IntPtr cPtr = AssimpPINVOKE.aiNodeAnimVector_getitem(swigCPtr, index);
aiNodeAnim ret = (cPtr == IntPtr.Zero) ? null : new aiNodeAnim(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private void setitem(int index, aiNodeAnim val) {
AssimpPINVOKE.aiNodeAnimVector_setitem(swigCPtr, index, aiNodeAnim.getCPtr(val));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void AddRange(aiNodeAnimVector values) {
AssimpPINVOKE.aiNodeAnimVector_AddRange(swigCPtr, aiNodeAnimVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiNodeAnimVector GetRange(int index, int count) {
IntPtr cPtr = AssimpPINVOKE.aiNodeAnimVector_GetRange(swigCPtr, index, count);
aiNodeAnimVector ret = (cPtr == IntPtr.Zero) ? null : new aiNodeAnimVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Insert(int index, aiNodeAnim x) {
AssimpPINVOKE.aiNodeAnimVector_Insert(swigCPtr, index, aiNodeAnim.getCPtr(x));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void InsertRange(int index, aiNodeAnimVector values) {
AssimpPINVOKE.aiNodeAnimVector_InsertRange(swigCPtr, index, aiNodeAnimVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveAt(int index) {
AssimpPINVOKE.aiNodeAnimVector_RemoveAt(swigCPtr, index);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveRange(int index, int count) {
AssimpPINVOKE.aiNodeAnimVector_RemoveRange(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public static aiNodeAnimVector Repeat(aiNodeAnim value, int count) {
IntPtr cPtr = AssimpPINVOKE.aiNodeAnimVector_Repeat(aiNodeAnim.getCPtr(value), count);
aiNodeAnimVector ret = (cPtr == IntPtr.Zero) ? null : new aiNodeAnimVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Reverse() {
AssimpPINVOKE.aiNodeAnimVector_Reverse__SWIG_0(swigCPtr);
}
public void Reverse(int index, int count) {
AssimpPINVOKE.aiNodeAnimVector_Reverse__SWIG_1(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void SetRange(int index, aiNodeAnimVector values) {
AssimpPINVOKE.aiNodeAnimVector_SetRange(swigCPtr, index, aiNodeAnimVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public bool Contains(aiNodeAnim value) {
bool ret = AssimpPINVOKE.aiNodeAnimVector_Contains(swigCPtr, aiNodeAnim.getCPtr(value));
return ret;
}
public int IndexOf(aiNodeAnim value) {
int ret = AssimpPINVOKE.aiNodeAnimVector_IndexOf(swigCPtr, aiNodeAnim.getCPtr(value));
return ret;
}
public int LastIndexOf(aiNodeAnim value) {
int ret = AssimpPINVOKE.aiNodeAnimVector_LastIndexOf(swigCPtr, aiNodeAnim.getCPtr(value));
return ret;
}
public bool Remove(aiNodeAnim value) {
bool ret = AssimpPINVOKE.aiNodeAnimVector_Remove(swigCPtr, aiNodeAnim.getCPtr(value));
return ret;
}
}

348
port/Assimp.NET/Assimp.NET_CS/aiNodeVector.cs
View File

@ -1,348 +0,0 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiNodeVector : IDisposable, System.Collections.IEnumerable
#if !SWIG_DOTNET_1
, System.Collections.Generic.IList<aiNode>
#endif
{
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiNodeVector(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiNodeVector obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiNodeVector() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
AssimpPINVOKE.delete_aiNodeVector(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiNodeVector(System.Collections.ICollection c) : this() {
if (c == null)
throw new ArgumentNullException("c");
foreach (aiNode element in c) {
this.Add(element);
}
}
public bool IsFixedSize {
get {
return false;
}
}
public bool IsReadOnly {
get {
return false;
}
}
public aiNode this[int index] {
get {
return getitem(index);
}
set {
setitem(index, value);
}
}
public int Capacity {
get {
return (int)capacity();
}
set {
if (value < size())
throw new ArgumentOutOfRangeException("Capacity");
reserve((uint)value);
}
}
public int Count {
get {
return (int)size();
}
}
public bool IsSynchronized {
get {
return false;
}
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array)
#else
public void CopyTo(aiNode[] array)
#endif
{
CopyTo(0, array, 0, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array, int arrayIndex)
#else
public void CopyTo(aiNode[] array, int arrayIndex)
#endif
{
CopyTo(0, array, arrayIndex, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(int index, System.Array array, int arrayIndex, int count)
#else
public void CopyTo(int index, aiNode[] array, int arrayIndex, int count)
#endif
{
if (array == null)
throw new ArgumentNullException("array");
if (index < 0)
throw new ArgumentOutOfRangeException("index", "Value is less than zero");
if (arrayIndex < 0)
throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
if (count < 0)
throw new ArgumentOutOfRangeException("count", "Value is less than zero");
if (array.Rank > 1)
throw new ArgumentException("Multi dimensional array.", "array");
if (index+count > this.Count || arrayIndex+count > array.Length)
throw new ArgumentException("Number of elements to copy is too large.");
for (int i=0; i<count; i++)
array.SetValue(getitemcopy(index+i), arrayIndex+i);
}
#if !SWIG_DOTNET_1
System.Collections.Generic.IEnumerator<aiNode> System.Collections.Generic.IEnumerable<aiNode>.GetEnumerator() {
return new aiNodeVectorEnumerator(this);
}
#endif
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
return new aiNodeVectorEnumerator(this);
}
public aiNodeVectorEnumerator GetEnumerator() {
return new aiNodeVectorEnumerator(this);
}
// Type-safe enumerator
/// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
/// whenever the collection is modified. This has been done for changes in the size of the
/// collection but not when one of the elements of the collection is modified as it is a bit
/// tricky to detect unmanaged code that modifies the collection under our feet.
public sealed class aiNodeVectorEnumerator : System.Collections.IEnumerator
#if !SWIG_DOTNET_1
, System.Collections.Generic.IEnumerator<aiNode>
#endif
{
private aiNodeVector collectionRef;
private int currentIndex;
private object currentObject;
private int currentSize;
public aiNodeVectorEnumerator(aiNodeVector collection) {
collectionRef = collection;
currentIndex = -1;
currentObject = null;
currentSize = collectionRef.Count;
}
// Type-safe iterator Current
public aiNode Current {
get {
if (currentIndex == -1)
throw new InvalidOperationException("Enumeration not started.");
if (currentIndex > currentSize - 1)
throw new InvalidOperationException("Enumeration finished.");
if (currentObject == null)
throw new InvalidOperationException("Collection modified.");
return (aiNode)currentObject;
}
}
// Type-unsafe IEnumerator.Current
object System.Collections.IEnumerator.Current {
get {
return Current;
}
}
public bool MoveNext() {
int size = collectionRef.Count;
bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
if (moveOkay) {
currentIndex++;
currentObject = collectionRef[currentIndex];
} else {
currentObject = null;
}
return moveOkay;
}
public void Reset() {
currentIndex = -1;
currentObject = null;
if (collectionRef.Count != currentSize) {
throw new InvalidOperationException("Collection modified.");
}
}
#if !SWIG_DOTNET_1
public void Dispose() {
currentIndex = -1;
currentObject = null;
}
#endif
}
public void Clear() {
AssimpPINVOKE.aiNodeVector_Clear(swigCPtr);
}
public void Add(aiNode x) {
AssimpPINVOKE.aiNodeVector_Add(swigCPtr, aiNode.getCPtr(x));
}
private uint size() {
uint ret = AssimpPINVOKE.aiNodeVector_size(swigCPtr);
return ret;
}
private uint capacity() {
uint ret = AssimpPINVOKE.aiNodeVector_capacity(swigCPtr);
return ret;
}
private void reserve(uint n) {
AssimpPINVOKE.aiNodeVector_reserve(swigCPtr, n);
}
public aiNodeVector() : this(AssimpPINVOKE.new_aiNodeVector__SWIG_0(), true) {
}
public aiNodeVector(aiNodeVector other) : this(AssimpPINVOKE.new_aiNodeVector__SWIG_1(aiNodeVector.getCPtr(other)), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiNodeVector(int capacity) : this(AssimpPINVOKE.new_aiNodeVector__SWIG_2(capacity), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
private aiNode getitemcopy(int index) {
IntPtr cPtr = AssimpPINVOKE.aiNodeVector_getitemcopy(swigCPtr, index);
aiNode ret = (cPtr == IntPtr.Zero) ? null : new aiNode(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private aiNode getitem(int index) {
IntPtr cPtr = AssimpPINVOKE.aiNodeVector_getitem(swigCPtr, index);
aiNode ret = (cPtr == IntPtr.Zero) ? null : new aiNode(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private void setitem(int index, aiNode val) {
AssimpPINVOKE.aiNodeVector_setitem(swigCPtr, index, aiNode.getCPtr(val));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void AddRange(aiNodeVector values) {
AssimpPINVOKE.aiNodeVector_AddRange(swigCPtr, aiNodeVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiNodeVector GetRange(int index, int count) {
IntPtr cPtr = AssimpPINVOKE.aiNodeVector_GetRange(swigCPtr, index, count);
aiNodeVector ret = (cPtr == IntPtr.Zero) ? null : new aiNodeVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Insert(int index, aiNode x) {
AssimpPINVOKE.aiNodeVector_Insert(swigCPtr, index, aiNode.getCPtr(x));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void InsertRange(int index, aiNodeVector values) {
AssimpPINVOKE.aiNodeVector_InsertRange(swigCPtr, index, aiNodeVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveAt(int index) {
AssimpPINVOKE.aiNodeVector_RemoveAt(swigCPtr, index);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveRange(int index, int count) {
AssimpPINVOKE.aiNodeVector_RemoveRange(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public static aiNodeVector Repeat(aiNode value, int count) {
IntPtr cPtr = AssimpPINVOKE.aiNodeVector_Repeat(aiNode.getCPtr(value), count);
aiNodeVector ret = (cPtr == IntPtr.Zero) ? null : new aiNodeVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Reverse() {
AssimpPINVOKE.aiNodeVector_Reverse__SWIG_0(swigCPtr);
}
public void Reverse(int index, int count) {
AssimpPINVOKE.aiNodeVector_Reverse__SWIG_1(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void SetRange(int index, aiNodeVector values) {
AssimpPINVOKE.aiNodeVector_SetRange(swigCPtr, index, aiNodeVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public bool Contains(aiNode value) {
bool ret = AssimpPINVOKE.aiNodeVector_Contains(swigCPtr, aiNode.getCPtr(value));
return ret;
}
public int IndexOf(aiNode value) {
int ret = AssimpPINVOKE.aiNodeVector_IndexOf(swigCPtr, aiNode.getCPtr(value));
return ret;
}
public int LastIndexOf(aiNode value) {
int ret = AssimpPINVOKE.aiNodeVector_LastIndexOf(swigCPtr, aiNode.getCPtr(value));
return ret;
}
public bool Remove(aiNode value) {
bool ret = AssimpPINVOKE.aiNodeVector_Remove(swigCPtr, aiNode.getCPtr(value));
return ret;
}
}

15
port/Assimp.NET/Assimp.NET_CS/aiOrigin.cs 100644
View File

@ -0,0 +1,15 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
public enum aiOrigin {
aiOrigin_SET = 0x0,
aiOrigin_CUR = 0x1,
aiOrigin_END = 0x2,
_AI_ORIGIN_ENFORCE_ENUM_SIZE = 0x7fffffff
}

93
port/Assimp.NET/Assimp.NET_CS/aiPlane.cs 100644
View File

@ -0,0 +1,93 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiPlane : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiPlane(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiPlane obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiPlane() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiPlane(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiPlane() : this(Assimp_NETPINVOKE.new_aiPlane__SWIG_0(), true) {
}
public aiPlane(float _a, float _b, float _c, float _d) : this(Assimp_NETPINVOKE.new_aiPlane__SWIG_1(_a, _b, _c, _d), true) {
}
public aiPlane(aiPlane o) : this(Assimp_NETPINVOKE.new_aiPlane__SWIG_2(aiPlane.getCPtr(o)), true) {
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public float a {
set {
Assimp_NETPINVOKE.aiPlane_a_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiPlane_a_get(swigCPtr);
return ret;
}
}
public float b {
set {
Assimp_NETPINVOKE.aiPlane_b_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiPlane_b_get(swigCPtr);
return ret;
}
}
public float c {
set {
Assimp_NETPINVOKE.aiPlane_c_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiPlane_c_get(swigCPtr);
return ret;
}
}
public float d {
set {
Assimp_NETPINVOKE.aiPlane_d_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiPlane_d_get(swigCPtr);
return ret;
}
}
}

35
port/Assimp.NET/Assimp.NET_CS/aiPostProcessSteps.cs 100644
View File

@ -0,0 +1,35 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
public enum aiPostProcessSteps {
aiProcess_CalcTangentSpace = 0x1,
aiProcess_JoinIdenticalVertices = 0x2,
aiProcess_MakeLeftHanded = 0x4,
aiProcess_Triangulate = 0x8,
aiProcess_RemoveComponent = 0x10,
aiProcess_GenNormals = 0x20,
aiProcess_GenSmoothNormals = 0x40,
aiProcess_SplitLargeMeshes = 0x80,
aiProcess_PreTransformVertices = 0x100,
aiProcess_LimitBoneWeights = 0x200,
aiProcess_ValidateDataStructure = 0x400,
aiProcess_ImproveCacheLocality = 0x800,
aiProcess_RemoveRedundantMaterials = 0x1000,
aiProcess_FixInfacingNormals = 0x2000,
aiProcess_SortByPType = 0x8000,
aiProcess_FindDegenerates = 0x10000,
aiProcess_FindInvalidData = 0x20000,
aiProcess_GenUVCoords = 0x40000,
aiProcess_TransformUVCoords = 0x80000,
aiProcess_FindInstances = 0x100000,
aiProcess_OptimizeMeshes = 0x200000,
aiProcess_OptimizeGraph = 0x400000,
aiProcess_FlipUVs = 0x800000,
aiProcess_FlipWindingOrder = 0x1000000
}

15
port/Assimp.NET/Assimp.NET_CS/aiPrimitiveType.cs 100644
View File

@ -0,0 +1,15 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
public enum aiPrimitiveType {
aiPrimitiveType_POINT = 0x1,
aiPrimitiveType_LINE = 0x2,
aiPrimitiveType_TRIANGLE = 0x4,
aiPrimitiveType_POLYGON = 0x8
}

15
port/Assimp.NET/Assimp.NET_CS/aiPropertyTypeInfo.cs 100644
View File

@ -0,0 +1,15 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
public enum aiPropertyTypeInfo {
aiPTI_Float = 0x1,
aiPTI_String = 0x3,
aiPTI_Integer = 0x4,
aiPTI_Buffer = 0x5
}

95
port/Assimp.NET/Assimp.NET_CS/aiQuatKey.cs 100644
View File

@ -0,0 +1,95 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiQuatKey : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiQuatKey(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiQuatKey obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiQuatKey() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiQuatKey(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public double mTime {
set {
Assimp_NETPINVOKE.aiQuatKey_mTime_set(swigCPtr, value);
}
get {
double ret = Assimp_NETPINVOKE.aiQuatKey_mTime_get(swigCPtr);
return ret;
}
}
public aiQuaternion mValue {
set {
Assimp_NETPINVOKE.aiQuatKey_mValue_set(swigCPtr, aiQuaternion.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiQuatKey_mValue_get(swigCPtr);
aiQuaternion ret = (cPtr == IntPtr.Zero) ? null : new aiQuaternion(cPtr, false);
return ret;
}
}
public aiQuatKey() : this(Assimp_NETPINVOKE.new_aiQuatKey__SWIG_0(), true) {
}
public aiQuatKey(double time, aiQuaternion value) : this(Assimp_NETPINVOKE.new_aiQuatKey__SWIG_1(time, aiQuaternion.getCPtr(value)), true) {
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public bool __equal__(aiQuatKey o) {
bool ret = Assimp_NETPINVOKE.aiQuatKey___equal__(swigCPtr, aiQuatKey.getCPtr(o));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public bool __nequal__(aiQuatKey o) {
bool ret = Assimp_NETPINVOKE.aiQuatKey___nequal__(swigCPtr, aiQuatKey.getCPtr(o));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public bool __smaller__(aiQuatKey o) {
bool ret = Assimp_NETPINVOKE.aiQuatKey___smaller__(swigCPtr, aiQuatKey.getCPtr(o));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public bool __greater__(aiQuatKey o) {
bool ret = Assimp_NETPINVOKE.aiQuatKey___greater__(swigCPtr, aiQuatKey.getCPtr(o));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}

148
port/Assimp.NET/Assimp.NET_CS/aiQuaternion.cs 100644
View File

@ -0,0 +1,148 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiQuaternion : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiQuaternion(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiQuaternion obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiQuaternion() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiQuaternion(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiQuaternion() : this(Assimp_NETPINVOKE.new_aiQuaternion__SWIG_0(), true) {
}
public aiQuaternion(float _w, float _x, float _y, float _z) : this(Assimp_NETPINVOKE.new_aiQuaternion__SWIG_1(_w, _x, _y, _z), true) {
}
public aiQuaternion(aiMatrix3x3 pRotMatrix) : this(Assimp_NETPINVOKE.new_aiQuaternion__SWIG_2(aiMatrix3x3.getCPtr(pRotMatrix)), true) {
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public aiQuaternion(float rotx, float roty, float rotz) : this(Assimp_NETPINVOKE.new_aiQuaternion__SWIG_3(rotx, roty, rotz), true) {
}
public aiQuaternion(aiVector3D axis, float angle) : this(Assimp_NETPINVOKE.new_aiQuaternion__SWIG_4(aiVector3D.getCPtr(axis), angle), true) {
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public aiQuaternion(aiVector3D normalized) : this(Assimp_NETPINVOKE.new_aiQuaternion__SWIG_5(aiVector3D.getCPtr(normalized)), true) {
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public aiMatrix3x3 GetMatrix() {
aiMatrix3x3 ret = new aiMatrix3x3(Assimp_NETPINVOKE.aiQuaternion_GetMatrix(swigCPtr), true);
return ret;
}
public bool __equal__(aiQuaternion o) {
bool ret = Assimp_NETPINVOKE.aiQuaternion___equal__(swigCPtr, aiQuaternion.getCPtr(o));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public bool __nequal__(aiQuaternion o) {
bool ret = Assimp_NETPINVOKE.aiQuaternion___nequal__(swigCPtr, aiQuaternion.getCPtr(o));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public aiQuaternion Normalize() {
aiQuaternion ret = new aiQuaternion(Assimp_NETPINVOKE.aiQuaternion_Normalize(swigCPtr), false);
return ret;
}
public aiQuaternion Conjugate() {
aiQuaternion ret = new aiQuaternion(Assimp_NETPINVOKE.aiQuaternion_Conjugate(swigCPtr), false);
return ret;
}
public aiVector3D Rotate(aiVector3D arg0) {
aiVector3D ret = new aiVector3D(Assimp_NETPINVOKE.aiQuaternion_Rotate(swigCPtr, aiVector3D.getCPtr(arg0)), true);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public aiQuaternion __mul__(aiQuaternion two) {
aiQuaternion ret = new aiQuaternion(Assimp_NETPINVOKE.aiQuaternion___mul__(swigCPtr, aiQuaternion.getCPtr(two)), true);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static void Interpolate(aiQuaternion pOut, aiQuaternion pStart, aiQuaternion pEnd, float pFactor) {
Assimp_NETPINVOKE.aiQuaternion_Interpolate(aiQuaternion.getCPtr(pOut), aiQuaternion.getCPtr(pStart), aiQuaternion.getCPtr(pEnd), pFactor);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public float w {
set {
Assimp_NETPINVOKE.aiQuaternion_w_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiQuaternion_w_get(swigCPtr);
return ret;
}
}
public float x {
set {
Assimp_NETPINVOKE.aiQuaternion_x_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiQuaternion_x_get(swigCPtr);
return ret;
}
}
public float y {
set {
Assimp_NETPINVOKE.aiQuaternion_y_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiQuaternion_y_get(swigCPtr);
return ret;
}
}
public float z {
set {
Assimp_NETPINVOKE.aiQuaternion_z_set(swigCPtr, value);
}
get {
float ret = Assimp_NETPINVOKE.aiQuaternion_z_get(swigCPtr);
return ret;
}
}
}

76
port/Assimp.NET/Assimp.NET_CS/aiRay.cs 100644
View File

@ -0,0 +1,76 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiRay : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiRay(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiRay obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiRay() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiRay(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiRay() : this(Assimp_NETPINVOKE.new_aiRay__SWIG_0(), true) {
}
public aiRay(aiVector3D _pos, aiVector3D _dir) : this(Assimp_NETPINVOKE.new_aiRay__SWIG_1(aiVector3D.getCPtr(_pos), aiVector3D.getCPtr(_dir)), true) {
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public aiRay(aiRay o) : this(Assimp_NETPINVOKE.new_aiRay__SWIG_2(aiRay.getCPtr(o)), true) {
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public aiVector3D pos {
set {
Assimp_NETPINVOKE.aiRay_pos_set(swigCPtr, aiVector3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiRay_pos_get(swigCPtr);
aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
return ret;
}
}
public aiVector3D dir {
set {
Assimp_NETPINVOKE.aiRay_dir_set(swigCPtr, aiVector3D.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiRay_dir_get(swigCPtr);
aiVector3D ret = (cPtr == IntPtr.Zero) ? null : new aiVector3D(cPtr, false);
return ret;
}
}
}

15
port/Assimp.NET/Assimp.NET_CS/aiReturn.cs 100644
View File

@ -0,0 +1,15 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
public enum aiReturn {
aiReturn_SUCCESS = 0x0,
aiReturn_FAILURE = -0x1,
aiReturn_OUTOFMEMORY = -0x3,
_AI_ENFORCE_ENUM_SIZE = 0x7fffffff
}

223
port/Assimp.NET/Assimp.NET_CS/aiScene.cs 100644
View File

@ -0,0 +1,223 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiScene : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiScene(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiScene obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiScene() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiScene(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public uint mFlags {
set {
Assimp_NETPINVOKE.aiScene_mFlags_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiScene_mFlags_get(swigCPtr);
return ret;
}
}
public aiNode mRootNode {
set {
Assimp_NETPINVOKE.aiScene_mRootNode_set(swigCPtr, aiNode.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiScene_mRootNode_get(swigCPtr);
aiNode ret = (cPtr == IntPtr.Zero) ? null : new aiNode(cPtr, false);
return ret;
}
}
public uint mNumMeshes {
set {
Assimp_NETPINVOKE.aiScene_mNumMeshes_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiScene_mNumMeshes_get(swigCPtr);
return ret;
}
}
public SWIGTYPE_p_p_aiMesh mMeshes {
set {
Assimp_NETPINVOKE.aiScene_mMeshes_set(swigCPtr, SWIGTYPE_p_p_aiMesh.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiScene_mMeshes_get(swigCPtr);
SWIGTYPE_p_p_aiMesh ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_p_aiMesh(cPtr, false);
return ret;
}
}
public uint mNumMaterials {
set {
Assimp_NETPINVOKE.aiScene_mNumMaterials_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiScene_mNumMaterials_get(swigCPtr);
return ret;
}
}
public SWIGTYPE_p_p_aiMaterial mMaterials {
set {
Assimp_NETPINVOKE.aiScene_mMaterials_set(swigCPtr, SWIGTYPE_p_p_aiMaterial.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiScene_mMaterials_get(swigCPtr);
SWIGTYPE_p_p_aiMaterial ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_p_aiMaterial(cPtr, false);
return ret;
}
}
public uint mNumAnimations {
set {
Assimp_NETPINVOKE.aiScene_mNumAnimations_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiScene_mNumAnimations_get(swigCPtr);
return ret;
}
}
public SWIGTYPE_p_p_aiAnimation mAnimations {
set {
Assimp_NETPINVOKE.aiScene_mAnimations_set(swigCPtr, SWIGTYPE_p_p_aiAnimation.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiScene_mAnimations_get(swigCPtr);
SWIGTYPE_p_p_aiAnimation ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_p_aiAnimation(cPtr, false);
return ret;
}
}
public uint mNumTextures {
set {
Assimp_NETPINVOKE.aiScene_mNumTextures_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiScene_mNumTextures_get(swigCPtr);
return ret;
}
}
public SWIGTYPE_p_p_aiTexture mTextures {
set {
Assimp_NETPINVOKE.aiScene_mTextures_set(swigCPtr, SWIGTYPE_p_p_aiTexture.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiScene_mTextures_get(swigCPtr);
SWIGTYPE_p_p_aiTexture ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_p_aiTexture(cPtr, false);
return ret;
}
}
public uint mNumLights {
set {
Assimp_NETPINVOKE.aiScene_mNumLights_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiScene_mNumLights_get(swigCPtr);
return ret;
}
}
public SWIGTYPE_p_p_aiLight mLights {
set {
Assimp_NETPINVOKE.aiScene_mLights_set(swigCPtr, SWIGTYPE_p_p_aiLight.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiScene_mLights_get(swigCPtr);
SWIGTYPE_p_p_aiLight ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_p_aiLight(cPtr, false);
return ret;
}
}
public uint mNumCameras {
set {
Assimp_NETPINVOKE.aiScene_mNumCameras_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiScene_mNumCameras_get(swigCPtr);
return ret;
}
}
public SWIGTYPE_p_p_aiCamera mCameras {
set {
Assimp_NETPINVOKE.aiScene_mCameras_set(swigCPtr, SWIGTYPE_p_p_aiCamera.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiScene_mCameras_get(swigCPtr);
SWIGTYPE_p_p_aiCamera ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_p_aiCamera(cPtr, false);
return ret;
}
}
public aiScene() : this(Assimp_NETPINVOKE.new_aiScene(), true) {
}
public bool HasMeshes() {
bool ret = Assimp_NETPINVOKE.aiScene_HasMeshes(swigCPtr);
return ret;
}
public bool HasMaterials() {
bool ret = Assimp_NETPINVOKE.aiScene_HasMaterials(swigCPtr);
return ret;
}
public bool HasLights() {
bool ret = Assimp_NETPINVOKE.aiScene_HasLights(swigCPtr);
return ret;
}
public bool HasTextures() {
bool ret = Assimp_NETPINVOKE.aiScene_HasTextures(swigCPtr);
return ret;
}
public bool HasCameras() {
bool ret = Assimp_NETPINVOKE.aiScene_HasCameras(swigCPtr);
return ret;
}
public bool HasAnimations() {
bool ret = Assimp_NETPINVOKE.aiScene_HasAnimations(swigCPtr);
return ret;
}
}

21
port/Assimp.NET/Assimp.NET_CS/aiShadingMode.cs 100644
View File

@ -0,0 +1,21 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
public enum aiShadingMode {
aiShadingMode_Flat = 0x1,
aiShadingMode_Gouraud = 0x2,
aiShadingMode_Phong = 0x3,
aiShadingMode_Blinn = 0x4,
aiShadingMode_Toon = 0x5,
aiShadingMode_OrenNayar = 0x6,
aiShadingMode_Minnaert = 0x7,
aiShadingMode_CookTorrance = 0x8,
aiShadingMode_NoShading = 0x9,
aiShadingMode_Fresnel = 0xa
}

104
port/Assimp.NET/Assimp.NET_CS/aiString.cs 100644
View File

@ -0,0 +1,104 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiString : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiString(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiString obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiString() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiString(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiString() : this(Assimp_NETPINVOKE.new_aiString__SWIG_0(), true) {
}
public aiString(aiString rOther) : this(Assimp_NETPINVOKE.new_aiString__SWIG_1(aiString.getCPtr(rOther)), true) {
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public aiString(string pString) : this(Assimp_NETPINVOKE.new_aiString__SWIG_2(pString), true) {
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public void Set(string pString) {
Assimp_NETPINVOKE.aiString_Set__SWIG_0(swigCPtr, pString);
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
}
public aiString __set__(string sz) {
aiString ret = new aiString(Assimp_NETPINVOKE.aiString___set____SWIG_0(swigCPtr, sz), false);
return ret;
}
public bool __equal__(aiString other) {
bool ret = Assimp_NETPINVOKE.aiString___equal__(swigCPtr, aiString.getCPtr(other));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public bool __nequal__(aiString other) {
bool ret = Assimp_NETPINVOKE.aiString___nequal__(swigCPtr, aiString.getCPtr(other));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Append(string app) {
Assimp_NETPINVOKE.aiString_Append(swigCPtr, app);
}
public void Clear() {
Assimp_NETPINVOKE.aiString_Clear(swigCPtr);
}
public uint length {
set {
Assimp_NETPINVOKE.aiString_length_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiString_length_get(swigCPtr);
return ret;
}
}
public string data {
set {
Assimp_NETPINVOKE.aiString_data_set(swigCPtr, value);
}
get {
string ret = Assimp_NETPINVOKE.aiString_data_get(swigCPtr);
return ret;
}
}
}

98
port/Assimp.NET/Assimp.NET_CS/aiTexel.cs 100644
View File

@ -0,0 +1,98 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiTexel : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiTexel(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiTexel obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiTexel() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiTexel(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public byte b {
set {
Assimp_NETPINVOKE.aiTexel_b_set(swigCPtr, value);
}
get {
byte ret = Assimp_NETPINVOKE.aiTexel_b_get(swigCPtr);
return ret;
}
}
public byte g {
set {
Assimp_NETPINVOKE.aiTexel_g_set(swigCPtr, value);
}
get {
byte ret = Assimp_NETPINVOKE.aiTexel_g_get(swigCPtr);
return ret;
}
}
public byte r {
set {
Assimp_NETPINVOKE.aiTexel_r_set(swigCPtr, value);
}
get {
byte ret = Assimp_NETPINVOKE.aiTexel_r_get(swigCPtr);
return ret;
}
}
public byte a {
set {
Assimp_NETPINVOKE.aiTexel_a_set(swigCPtr, value);
}
get {
byte ret = Assimp_NETPINVOKE.aiTexel_a_get(swigCPtr);
return ret;
}
}
public bool __equal__(aiTexel other) {
bool ret = Assimp_NETPINVOKE.aiTexel___equal__(swigCPtr, aiTexel.getCPtr(other));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public bool __nequal__(aiTexel other) {
bool ret = Assimp_NETPINVOKE.aiTexel___nequal__(swigCPtr, aiTexel.getCPtr(other));
if (Assimp_NETPINVOKE.SWIGPendingException.Pending) throw Assimp_NETPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public aiTexel() : this(Assimp_NETPINVOKE.new_aiTexel(), true) {
}
}

92
port/Assimp.NET/Assimp.NET_CS/aiTexture.cs 100644
View File

@ -0,0 +1,92 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiTexture : IDisposable {
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiTexture(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiTexture obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiTexture() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
Assimp_NETPINVOKE.delete_aiTexture(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public uint mWidth {
set {
Assimp_NETPINVOKE.aiTexture_mWidth_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiTexture_mWidth_get(swigCPtr);
return ret;
}
}
public uint mHeight {
set {
Assimp_NETPINVOKE.aiTexture_mHeight_set(swigCPtr, value);
}
get {
uint ret = Assimp_NETPINVOKE.aiTexture_mHeight_get(swigCPtr);
return ret;
}
}
public string achFormatHint {
set {
Assimp_NETPINVOKE.aiTexture_achFormatHint_set(swigCPtr, value);
}
get {
string ret = Assimp_NETPINVOKE.aiTexture_achFormatHint_get(swigCPtr);
return ret;
}
}
public aiTexel pcData {
set {
Assimp_NETPINVOKE.aiTexture_pcData_set(swigCPtr, aiTexel.getCPtr(value));
}
get {
IntPtr cPtr = Assimp_NETPINVOKE.aiTexture_pcData_get(swigCPtr);
aiTexel ret = (cPtr == IntPtr.Zero) ? null : new aiTexel(cPtr, false);
return ret;
}
}
public bool CheckFormat(string s) {
bool ret = Assimp_NETPINVOKE.aiTexture_CheckFormat(swigCPtr, s);
return ret;
}
public aiTexture() : this(Assimp_NETPINVOKE.new_aiTexture(), true) {
}
}

14
port/Assimp.NET/Assimp.NET_CS/aiTextureFlags.cs 100644
View File

@ -0,0 +1,14 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
public enum aiTextureFlags {
aiTextureFlags_Invert = 0x1,
aiTextureFlags_UseAlpha = 0x2,
aiTextureFlags_IgnoreAlpha = 0x4
}

15
port/Assimp.NET/Assimp.NET_CS/aiTextureMapMode.cs 100644
View File

@ -0,0 +1,15 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
public enum aiTextureMapMode {
aiTextureMapMode_Wrap = 0x0,
aiTextureMapMode_Clamp = 0x1,
aiTextureMapMode_Decal = 0x3,
aiTextureMapMode_Mirror = 0x2
}

17
port/Assimp.NET/Assimp.NET_CS/aiTextureMapping.cs 100644
View File

@ -0,0 +1,17 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
public enum aiTextureMapping {
aiTextureMapping_UV = 0x0,
aiTextureMapping_SPHERE = 0x1,
aiTextureMapping_CYLINDER = 0x2,
aiTextureMapping_BOX = 0x3,
aiTextureMapping_PLANE = 0x4,
aiTextureMapping_OTHER = 0x5
}

17
port/Assimp.NET/Assimp.NET_CS/aiTextureOp.cs 100644
View File

@ -0,0 +1,17 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
public enum aiTextureOp {
aiTextureOp_Multiply = 0x0,
aiTextureOp_Add = 0x1,
aiTextureOp_Subtract = 0x2,
aiTextureOp_Divide = 0x3,
aiTextureOp_SmoothAdd = 0x4,
aiTextureOp_SignedAdd = 0x5
}

24
port/Assimp.NET/Assimp.NET_CS/aiTextureType.cs 100644
View File

@ -0,0 +1,24 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
public enum aiTextureType {
aiTextureType_NONE = 0x0,
aiTextureType_DIFFUSE = 0x1,
aiTextureType_SPECULAR = 0x2,
aiTextureType_AMBIENT = 0x3,
aiTextureType_EMISSIVE = 0x4,
aiTextureType_HEIGHT = 0x5,
aiTextureType_NORMALS = 0x6,
aiTextureType_SHININESS = 0x7,
aiTextureType_OPACITY = 0x8,
aiTextureType_DISPLACEMENT = 0x9,
aiTextureType_LIGHTMAP = 0xA,
aiTextureType_REFLECTION = 0xB,
aiTextureType_UNKNOWN = 0xC
}

348
port/Assimp.NET/Assimp.NET_CS/aiTextureVector.cs
View File

@ -1,348 +0,0 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 1.3.40
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */
using System;
using System.Runtime.InteropServices;
public class aiTextureVector : IDisposable, System.Collections.IEnumerable
#if !SWIG_DOTNET_1
, System.Collections.Generic.IList<aiTexture>
#endif
{
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiTextureVector(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiTextureVector obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiTextureVector() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
AssimpPINVOKE.delete_aiTextureVector(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiTextureVector(System.Collections.ICollection c) : this() {
if (c == null)
throw new ArgumentNullException("c");
foreach (aiTexture element in c) {
this.Add(element);
}
}
public bool IsFixedSize {
get {
return false;
}
}
public bool IsReadOnly {
get {
return false;
}
}
public aiTexture this[int index] {
get {
return getitem(index);
}
set {
setitem(index, value);
}
}
public int Capacity {
get {
return (int)capacity();
}
set {
if (value < size())
throw new ArgumentOutOfRangeException("Capacity");
reserve((uint)value);
}
}
public int Count {
get {
return (int)size();
}
}
public bool IsSynchronized {
get {
return false;
}
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array)
#else
public void CopyTo(aiTexture[] array)
#endif
{
CopyTo(0, array, 0, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array, int arrayIndex)
#else
public void CopyTo(aiTexture[] array, int arrayIndex)
#endif
{
CopyTo(0, array, arrayIndex, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(int index, System.Array array, int arrayIndex, int count)
#else
public void CopyTo(int index, aiTexture[] array, int arrayIndex, int count)
#endif
{
if (array == null)
throw new ArgumentNullException("array");
if (index < 0)
throw new ArgumentOutOfRangeException("index", "Value is less than zero");
if (arrayIndex < 0)
throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
if (count < 0)
throw new ArgumentOutOfRangeException("count", "Value is less than zero");
if (array.Rank > 1)
throw new ArgumentException("Multi dimensional array.", "array");
if (index+count > this.Count || arrayIndex+count > array.Length)
throw new ArgumentException("Number of elements to copy is too large.");
for (int i=0; i<count; i++)
array.SetValue(getitemcopy(index+i), arrayIndex+i);
}
#if !SWIG_DOTNET_1
System.Collections.Generic.IEnumerator<aiTexture> System.Collections.Generic.IEnumerable<aiTexture>.GetEnumerator() {
return new aiTextureVectorEnumerator(this);
}
#endif
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
return new aiTextureVectorEnumerator(this);
}
public aiTextureVectorEnumerator GetEnumerator() {
return new aiTextureVectorEnumerator(this);
}
// Type-safe enumerator
/// Note that the IEnumerator documentation requires an InvalidOperationException to be thrown
/// whenever the collection is modified. This has been done for changes in the size of the
/// collection but not when one of the elements of the collection is modified as it is a bit
/// tricky to detect unmanaged code that modifies the collection under our feet.
public sealed class aiTextureVectorEnumerator : System.Collections.IEnumerator
#if !SWIG_DOTNET_1
, System.Collections.Generic.IEnumerator<aiTexture>
#endif
{
private aiTextureVector collectionRef;
private int currentIndex;
private object currentObject;
private int currentSize;
public aiTextureVectorEnumerator(aiTextureVector collection) {
collectionRef = collection;
currentIndex = -1;
currentObject = null;
currentSize = collectionRef.Count;
}
// Type-safe iterator Current
public aiTexture Current {
get {
if (currentIndex == -1)
throw new InvalidOperationException("Enumeration not started.");
if (currentIndex > currentSize - 1)
throw new InvalidOperationException("Enumeration finished.");
if (currentObject == null)
throw new InvalidOperationException("Collection modified.");
return (aiTexture)currentObject;
}
}
// Type-unsafe IEnumerator.Current
object System.Collections.IEnumerator.Current {
get {
return Current;
}
}
public bool MoveNext() {
int size = collectionRef.Count;
bool moveOkay = (currentIndex+1 < size) && (size == currentSize);
if (moveOkay) {
currentIndex++;
currentObject = collectionRef[currentIndex];
} else {
currentObject = null;
}
return moveOkay;
}
public void Reset() {
currentIndex = -1;
currentObject = null;
if (collectionRef.Count != currentSize) {
throw new InvalidOperationException("Collection modified.");
}
}
#if !SWIG_DOTNET_1
public void Dispose() {
currentIndex = -1;
currentObject = null;
}
#endif
}
public void Clear() {
AssimpPINVOKE.aiTextureVector_Clear(swigCPtr);
}
public void Add(aiTexture x) {
AssimpPINVOKE.aiTextureVector_Add(swigCPtr, aiTexture.getCPtr(x));
}
private uint size() {
uint ret = AssimpPINVOKE.aiTextureVector_size(swigCPtr);
return ret;
}
private uint capacity() {
uint ret = AssimpPINVOKE.aiTextureVector_capacity(swigCPtr);
return ret;
}
private void reserve(uint n) {
AssimpPINVOKE.aiTextureVector_reserve(swigCPtr, n);
}
public aiTextureVector() : this(AssimpPINVOKE.new_aiTextureVector__SWIG_0(), true) {
}
public aiTextureVector(aiTextureVector other) : this(AssimpPINVOKE.new_aiTextureVector__SWIG_1(aiTextureVector.getCPtr(other)), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiTextureVector(int capacity) : this(AssimpPINVOKE.new_aiTextureVector__SWIG_2(capacity), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
private aiTexture getitemcopy(int index) {
IntPtr cPtr = AssimpPINVOKE.aiTextureVector_getitemcopy(swigCPtr, index);
aiTexture ret = (cPtr == IntPtr.Zero) ? null : new aiTexture(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private aiTexture getitem(int index) {
IntPtr cPtr = AssimpPINVOKE.aiTextureVector_getitem(swigCPtr, index);
aiTexture ret = (cPtr == IntPtr.Zero) ? null : new aiTexture(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private void setitem(int index, aiTexture val) {
AssimpPINVOKE.aiTextureVector_setitem(swigCPtr, index, aiTexture.getCPtr(val));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void AddRange(aiTextureVector values) {
AssimpPINVOKE.aiTextureVector_AddRange(swigCPtr, aiTextureVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiTextureVector GetRange(int index, int count) {
IntPtr cPtr = AssimpPINVOKE.aiTextureVector_GetRange(swigCPtr, index, count);
aiTextureVector ret = (cPtr == IntPtr.Zero) ? null : new aiTextureVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Insert(int index, aiTexture x) {
AssimpPINVOKE.aiTextureVector_Insert(swigCPtr, index, aiTexture.getCPtr(x));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void InsertRange(int index, aiTextureVector values) {
AssimpPINVOKE.aiTextureVector_InsertRange(swigCPtr, index, aiTextureVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveAt(int index) {
AssimpPINVOKE.aiTextureVector_RemoveAt(swigCPtr, index);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveRange(int index, int count) {
AssimpPINVOKE.aiTextureVector_RemoveRange(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public static aiTextureVector Repeat(aiTexture value, int count) {
IntPtr cPtr = AssimpPINVOKE.aiTextureVector_Repeat(aiTexture.getCPtr(value), count);
aiTextureVector ret = (cPtr == IntPtr.Zero) ? null : new aiTextureVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Reverse() {
AssimpPINVOKE.aiTextureVector_Reverse__SWIG_0(swigCPtr);
}
public void Reverse(int index, int count) {
AssimpPINVOKE.aiTextureVector_Reverse__SWIG_1(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void SetRange(int index, aiTextureVector values) {
AssimpPINVOKE.aiTextureVector_SetRange(swigCPtr, index, aiTextureVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public bool Contains(aiTexture value) {
bool ret = AssimpPINVOKE.aiTextureVector_Contains(swigCPtr, aiTexture.getCPtr(value));
return ret;
}
public int IndexOf(aiTexture value) {
int ret = AssimpPINVOKE.aiTextureVector_IndexOf(swigCPtr, aiTexture.getCPtr(value));
return ret;
}
public int LastIndexOf(aiTexture value) {
int ret = AssimpPINVOKE.aiTextureVector_LastIndexOf(swigCPtr, aiTexture.getCPtr(value));
return ret;
}
public bool Remove(aiTexture value) {
bool ret = AssimpPINVOKE.aiTextureVector_Remove(swigCPtr, aiTexture.getCPtr(value));
return ret;
}
}

Some files were not shown because too many files have changed in this diff Show More