Update of C#/.NET bindings plus working Managed DirectX Viewer that displays standard DirectX Fixed Function Materials (Ambient, Diffuse, Specular, Emissive) and the first set of texture coordinates if contained in the model.

git-svn-id: https://assimp.svn.sourceforge.net/svnroot/assimp/trunk@782 67173fc5-114c-0410-ac8e-9d2fd5bffc1f
This commit is contained in:
adamdavidson
2010-07-12 13:13:43 +00:00
parent 9d69165ae7
commit 1c0e25288b
133 changed files with 33365 additions and 7006 deletions

View File

@@ -0,0 +1,348 @@
/* ----------------------------------------------------------------------------
* This file was automatically generated by SWIG (http://www.swig.org).
* Version 2.0.0
*
* 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 aiMeshKeyVector : IDisposable, System.Collections.IEnumerable
#if !SWIG_DOTNET_1
, System.Collections.Generic.IList<aiMeshKey>
#endif
{
private HandleRef swigCPtr;
protected bool swigCMemOwn;
internal aiMeshKeyVector(IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new HandleRef(this, cPtr);
}
internal static HandleRef getCPtr(aiMeshKeyVector obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
~aiMeshKeyVector() {
Dispose();
}
public virtual void Dispose() {
lock(this) {
if (swigCPtr.Handle != IntPtr.Zero) {
if (swigCMemOwn) {
swigCMemOwn = false;
AssimpPINVOKE.delete_aiMeshKeyVector(swigCPtr);
}
swigCPtr = new HandleRef(null, IntPtr.Zero);
}
GC.SuppressFinalize(this);
}
}
public aiMeshKeyVector(System.Collections.ICollection c) : this() {
if (c == null)
throw new ArgumentNullException("c");
foreach (aiMeshKey element in c) {
this.Add(element);
}
}
public bool IsFixedSize {
get {
return false;
}
}
public bool IsReadOnly {
get {
return false;
}
}
public aiMeshKey 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(aiMeshKey[] array)
#endif
{
CopyTo(0, array, 0, this.Count);
}
#if SWIG_DOTNET_1
public void CopyTo(System.Array array, int arrayIndex)
#else
public void CopyTo(aiMeshKey[] 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, aiMeshKey[] 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<aiMeshKey> System.Collections.Generic.IEnumerable<aiMeshKey>.GetEnumerator() {
return new aiMeshKeyVectorEnumerator(this);
}
#endif
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
return new aiMeshKeyVectorEnumerator(this);
}
public aiMeshKeyVectorEnumerator GetEnumerator() {
return new aiMeshKeyVectorEnumerator(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 aiMeshKeyVectorEnumerator : System.Collections.IEnumerator
#if !SWIG_DOTNET_1
, System.Collections.Generic.IEnumerator<aiMeshKey>
#endif
{
private aiMeshKeyVector collectionRef;
private int currentIndex;
private object currentObject;
private int currentSize;
public aiMeshKeyVectorEnumerator(aiMeshKeyVector collection) {
collectionRef = collection;
currentIndex = -1;
currentObject = null;
currentSize = collectionRef.Count;
}
// Type-safe iterator Current
public aiMeshKey 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 (aiMeshKey)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.aiMeshKeyVector_Clear(swigCPtr);
}
public void Add(aiMeshKey x) {
AssimpPINVOKE.aiMeshKeyVector_Add(swigCPtr, aiMeshKey.getCPtr(x));
}
private uint size() {
uint ret = AssimpPINVOKE.aiMeshKeyVector_size(swigCPtr);
return ret;
}
private uint capacity() {
uint ret = AssimpPINVOKE.aiMeshKeyVector_capacity(swigCPtr);
return ret;
}
private void reserve(uint n) {
AssimpPINVOKE.aiMeshKeyVector_reserve(swigCPtr, n);
}
public aiMeshKeyVector() : this(AssimpPINVOKE.new_aiMeshKeyVector__SWIG_0(), true) {
}
public aiMeshKeyVector(aiMeshKeyVector other) : this(AssimpPINVOKE.new_aiMeshKeyVector__SWIG_1(aiMeshKeyVector.getCPtr(other)), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiMeshKeyVector(int capacity) : this(AssimpPINVOKE.new_aiMeshKeyVector__SWIG_2(capacity), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
private aiMeshKey getitemcopy(int index) {
IntPtr cPtr = AssimpPINVOKE.aiMeshKeyVector_getitemcopy(swigCPtr, index);
aiMeshKey ret = (cPtr == IntPtr.Zero) ? null : new aiMeshKey(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private aiMeshKey getitem(int index) {
IntPtr cPtr = AssimpPINVOKE.aiMeshKeyVector_getitem(swigCPtr, index);
aiMeshKey ret = (cPtr == IntPtr.Zero) ? null : new aiMeshKey(cPtr, false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private void setitem(int index, aiMeshKey val) {
AssimpPINVOKE.aiMeshKeyVector_setitem(swigCPtr, index, aiMeshKey.getCPtr(val));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void AddRange(aiMeshKeyVector values) {
AssimpPINVOKE.aiMeshKeyVector_AddRange(swigCPtr, aiMeshKeyVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiMeshKeyVector GetRange(int index, int count) {
IntPtr cPtr = AssimpPINVOKE.aiMeshKeyVector_GetRange(swigCPtr, index, count);
aiMeshKeyVector ret = (cPtr == IntPtr.Zero) ? null : new aiMeshKeyVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Insert(int index, aiMeshKey x) {
AssimpPINVOKE.aiMeshKeyVector_Insert(swigCPtr, index, aiMeshKey.getCPtr(x));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void InsertRange(int index, aiMeshKeyVector values) {
AssimpPINVOKE.aiMeshKeyVector_InsertRange(swigCPtr, index, aiMeshKeyVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveAt(int index) {
AssimpPINVOKE.aiMeshKeyVector_RemoveAt(swigCPtr, index);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void RemoveRange(int index, int count) {
AssimpPINVOKE.aiMeshKeyVector_RemoveRange(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public static aiMeshKeyVector Repeat(aiMeshKey value, int count) {
IntPtr cPtr = AssimpPINVOKE.aiMeshKeyVector_Repeat(aiMeshKey.getCPtr(value), count);
aiMeshKeyVector ret = (cPtr == IntPtr.Zero) ? null : new aiMeshKeyVector(cPtr, true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void Reverse() {
AssimpPINVOKE.aiMeshKeyVector_Reverse__SWIG_0(swigCPtr);
}
public void Reverse(int index, int count) {
AssimpPINVOKE.aiMeshKeyVector_Reverse__SWIG_1(swigCPtr, index, count);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public void SetRange(int index, aiMeshKeyVector values) {
AssimpPINVOKE.aiMeshKeyVector_SetRange(swigCPtr, index, aiMeshKeyVector.getCPtr(values));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public bool Contains(aiMeshKey value) {
bool ret = AssimpPINVOKE.aiMeshKeyVector_Contains(swigCPtr, aiMeshKey.getCPtr(value));
return ret;
}
public int IndexOf(aiMeshKey value) {
int ret = AssimpPINVOKE.aiMeshKeyVector_IndexOf(swigCPtr, aiMeshKey.getCPtr(value));
return ret;
}
public int LastIndexOf(aiMeshKey value) {
int ret = AssimpPINVOKE.aiMeshKeyVector_LastIndexOf(swigCPtr, aiMeshKey.getCPtr(value));
return ret;
}
public bool Remove(aiMeshKey value) {
bool ret = AssimpPINVOKE.aiMeshKeyVector_Remove(swigCPtr, aiMeshKey.getCPtr(value));
return ret;
}
}