public aiAABB(aiVector3D min, aiVector3D max) : this(assimp_swigPINVOKE.new_aiAABB__SWIG_1(aiVector3D.getCPtr(min), aiVector3D.getCPtr(max)), true)
{
if (assimp_swigPINVOKE.SWIGPendingException.Pending)
{
throw assimp_swigPINVOKE.SWIGPendingException.Retrieve();
}
}
public aiVector3D(aiVector3D o) : this(AssimpPINVOKE.new_aiVector3D__SWIG_3(aiVector3D.getCPtr(o)), true)
{
if (AssimpPINVOKE.SWIGPendingException.Pending)
{
throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
}
public aiQuaternion(aiVector3D normalized) : this(assimp_swigPINVOKE.new_aiQuaternion__SWIG_5(aiVector3D.getCPtr(normalized)), true)
{
if (assimp_swigPINVOKE.SWIGPendingException.Pending)
{
throw assimp_swigPINVOKE.SWIGPendingException.Retrieve();
}
}
public aiQuaternion(aiVector3D axis, float angle) : this(assimp_swigPINVOKE.new_aiQuaternion__SWIG_4(aiVector3D.getCPtr(axis), angle), true)
{
if (assimp_swigPINVOKE.SWIGPendingException.Pending)
{
throw assimp_swigPINVOKE.SWIGPendingException.Retrieve();
}
}
public aiMatrix4x4(aiVector3D scaling, aiQuaternion rotation, aiVector3D position) : this(assimp_swigPINVOKE.new_aiMatrix4x4__SWIG_3(aiVector3D.getCPtr(scaling), aiQuaternion.getCPtr(rotation), aiVector3D.getCPtr(position)), true)
{
if (assimp_swigPINVOKE.SWIGPendingException.Pending)
{
throw assimp_swigPINVOKE.SWIGPendingException.Retrieve();
}
}
public aiVectorKey(double time, aiVector3D value) : this(assimp_swigPINVOKE.new_aiVectorKey__SWIG_1(time, aiVector3D.getCPtr(value)), true)
{
if (assimp_swigPINVOKE.SWIGPendingException.Pending)
{
throw assimp_swigPINVOKE.SWIGPendingException.Retrieve();
}
}
public aiRay(aiVector3D _pos, aiVector3D _dir) : this(AssimpPINVOKE.new_aiRay__SWIG_1(aiVector3D.getCPtr(_pos), aiVector3D.getCPtr(_dir)), true)
{
if (AssimpPINVOKE.SWIGPendingException.Pending)
{
throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
}
public void Decompose(aiVector3D scaling, aiQuaternion rotation, aiVector3D position)
{
AssimpPINVOKE.aiMatrix4x4_Decompose(swigCPtr, aiVector3D.getCPtr(scaling), aiQuaternion.getCPtr(rotation), aiVector3D.getCPtr(position));
if (AssimpPINVOKE.SWIGPendingException.Pending)
{
throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
}
public void Decompose(aiVector3D pScaling, aiVector3D pRotation, aiVector3D pPosition)
{
assimp_swigPINVOKE.aiMatrix4x4_Decompose__SWIG_1(swigCPtr, aiVector3D.getCPtr(pScaling), aiVector3D.getCPtr(pRotation), aiVector3D.getCPtr(pPosition));
if (assimp_swigPINVOKE.SWIGPendingException.Pending)
{
throw assimp_swigPINVOKE.SWIGPendingException.Retrieve();
}
}
public void DecomposeNoScaling(aiQuaternion rotation, aiVector3D position)
{
assimp_swigPINVOKE.aiMatrix4x4_DecomposeNoScaling(swigCPtr, aiQuaternion.getCPtr(rotation), aiVector3D.getCPtr(position));
if (assimp_swigPINVOKE.SWIGPendingException.Pending)
{
throw assimp_swigPINVOKE.SWIGPendingException.Retrieve();
}
}
public void SetVector3D(uint index, string key, aiVector3D value)
{
assimp_swigPINVOKE.aiMetadata_SetVector3D(swigCPtr, index, key, aiVector3D.getCPtr(value));
if (assimp_swigPINVOKE.SWIGPendingException.Pending)
{
throw assimp_swigPINVOKE.SWIGPendingException.Retrieve();
}
}
public void SetVector3D(aiVector3D value)
{
assimp_swigPINVOKE.aiMetadataEntry_SetVector3D(swigCPtr, aiVector3D.getCPtr(value));
if (assimp_swigPINVOKE.SWIGPendingException.Pending)
{
throw assimp_swigPINVOKE.SWIGPendingException.Retrieve();
}
}
public bool GetVector3D(string key, aiVector3D OUTPUT)
{
bool ret = assimp_swigPINVOKE.aiMetadata_GetVector3D__SWIG_1(swigCPtr, key, aiVector3D.getCPtr(OUTPUT));
if (assimp_swigPINVOKE.SWIGPendingException.Pending)
{
throw assimp_swigPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public aiVector3D Rotate(aiVector3D in_)
{
aiVector3D ret = new aiVector3D(assimp_swigPINVOKE.aiQuaternion_Rotate(swigCPtr, aiVector3D.getCPtr(in_)), true);
if (assimp_swigPINVOKE.SWIGPendingException.Pending)
{
throw assimp_swigPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public static aiMatrix3x3 FromToMatrix(aiVector3D from, aiVector3D to, aiMatrix3x3 arg2)
{
aiMatrix3x3 ret = new aiMatrix3x3(AssimpPINVOKE.aiMatrix3x3_FromToMatrix(aiVector3D.getCPtr(from), aiVector3D.getCPtr(to), aiMatrix3x3.getCPtr(arg2)), false);
if (AssimpPINVOKE.SWIGPendingException.Pending)
{
throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public static aiMetadataType GetAiType(aiVector3D arg0)
{
aiMetadataType ret = (aiMetadataType)assimp_swigPINVOKE.GetAiType__SWIG_6(aiVector3D.getCPtr(arg0));
if (assimp_swigPINVOKE.SWIGPendingException.Pending)
{
throw assimp_swigPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public aiVector3D SymMul(aiVector3D o)
{
aiVector3D ret = new aiVector3D(AssimpPINVOKE.aiVector3D_SymMul(swigCPtr, aiVector3D.getCPtr(o)), true);
if (AssimpPINVOKE.SWIGPendingException.Pending)
{
throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public bool __nequal__(aiVector3D other)
{
bool ret = AssimpPINVOKE.aiVector3D___nequal__(swigCPtr, aiVector3D.getCPtr(other));
if (AssimpPINVOKE.SWIGPendingException.Pending)
{
throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public static aiMatrix3x3 Rotation(float a, aiVector3D axis, aiMatrix3x3 arg2)
{
aiMatrix3x3 ret = new aiMatrix3x3(AssimpPINVOKE.aiMatrix3x3_Rotation(a, aiVector3D.getCPtr(axis), aiMatrix3x3.getCPtr(arg2)), false);
if (AssimpPINVOKE.SWIGPendingException.Pending)
{
throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public static aiMatrix4x4 FromToMatrix(aiVector3D from, aiVector3D to, aiMatrix4x4 out_)
{
aiMatrix4x4 ret = new aiMatrix4x4(assimp_swigPINVOKE.aiMatrix4x4_FromToMatrix(aiVector3D.getCPtr(from), aiVector3D.getCPtr(to), aiMatrix4x4.getCPtr(out_)), false);
if (assimp_swigPINVOKE.SWIGPendingException.Pending)
{
throw assimp_swigPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public aiVector3D Rotate(aiVector3D arg0)
{
aiVector3D ret = new aiVector3D(AssimpPINVOKE.aiQuaternion_Rotate(swigCPtr, aiVector3D.getCPtr(arg0)), true);
if (AssimpPINVOKE.SWIGPendingException.Pending)
{
throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public bool SetTextureMappingAxis(aiTextureType type, uint index, aiVector3D INPUT)
{
bool ret = assimp_swigPINVOKE.aiMaterial_SetTextureMappingAxis(swigCPtr, (int)type, index, aiVector3D.getCPtr(INPUT));
if (assimp_swigPINVOKE.SWIGPendingException.Pending)
{
throw assimp_swigPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public aiVector3D __mulnset__(aiMatrix4x4 mat)
{
aiVector3D ret = new aiVector3D(AssimpPINVOKE.aiVector3D___mulnset____SWIG_2(swigCPtr, aiMatrix4x4.getCPtr(mat)), false);
if (AssimpPINVOKE.SWIGPendingException.Pending)
{
throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public static aiMatrix4x4 Rotation(float a, aiVector3D axis, aiMatrix4x4 out_)
{
aiMatrix4x4 ret = new aiMatrix4x4(assimp_swigPINVOKE.aiMatrix4x4_Rotation(a, aiVector3D.getCPtr(axis), aiMatrix4x4.getCPtr(out_)), false);
if (assimp_swigPINVOKE.SWIGPendingException.Pending)
{
throw assimp_swigPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public static aiMatrix4x4 Scaling(aiVector3D v, aiMatrix4x4 out_)
{
aiMatrix4x4 ret = new aiMatrix4x4(assimp_swigPINVOKE.aiMatrix4x4_Scaling(aiVector3D.getCPtr(v), aiMatrix4x4.getCPtr(out_)), false);
if (assimp_swigPINVOKE.SWIGPendingException.Pending)
{
throw assimp_swigPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public aiVector3D __subnset__(aiVector3D o)
{
aiVector3D ret = new aiVector3D(AssimpPINVOKE.aiVector3D___subnset__(swigCPtr, aiVector3D.getCPtr(o)), false);
if (AssimpPINVOKE.SWIGPendingException.Pending)
{
throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public static aiMatrix4x4 Scaling(aiVector3D v, aiMatrix4x4 arg1)
{
aiMatrix4x4 ret = new aiMatrix4x4(AssimpPINVOKE.aiMatrix4x4_Scaling(aiVector3D.getCPtr(v), aiMatrix4x4.getCPtr(arg1)), false);
if (AssimpPINVOKE.SWIGPendingException.Pending)
{
throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public aiMatrix4x4 FromEulerAnglesXYZ(aiVector3D blubb)
{
aiMatrix4x4 ret = new aiMatrix4x4(assimp_swigPINVOKE.aiMatrix4x4_FromEulerAnglesXYZ__SWIG_1(swigCPtr, aiVector3D.getCPtr(blubb)), false);
if (assimp_swigPINVOKE.SWIGPendingException.Pending)
{
throw assimp_swigPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
//-------------------------------------------------------------------------------
// Handle mouse input for movements of the skybox
//
// The skybox can be moved by holding both the left and the right mouse button
// pressed. Rotation is possible in x and y direction.
//-------------------------------------------------------------------------------
void HandleMouseInputSkyBox( void )
{
POINT mousePos;
GetCursorPos( &mousePos );
ScreenToClient( GetDlgItem(g_hDlg,IDC_RT), &mousePos );
g_mousePos.X = mousePos.X;
g_mousePos.Y = mousePos.Y;
aiMatrix4x4 matRotation;
if (g_bMousePressedBoth )
{
int nXDiff = -(g_mousePos.X - g_LastmousePos.X);
int nYDiff = -(g_mousePos.Y - g_LastmousePos.Y);
aiMatrix4x4 matWorld;
if( 0 != nYDiff)
{
aiVector3D v = aiVector3D(1.0f,0.0f,0.0f);
D3DXMatrixRotationAxis( (D3DXMATRIX*) &matWorld, (D3DXVECTOR3*)&v, D3DXToRadian((float)nYDiff / 2.0f));
CBackgroundPainter::Instance().RotateSB(&matWorld);
}
if( 0 != nXDiff)
{
aiMatrix4x4 matWorldOld;
if( 0 != nYDiff)
{
matWorldOld = matWorld;
}
aiVector3D v = aiVector3D(0.0f,1.0f,0.0f);
D3DXMatrixRotationAxis( (D3DXMATRIX*)&matWorld, (D3DXVECTOR3*)&v, D3DXToRadian((float)nXDiff / 2.0f) );
matWorld = matWorldOld * matWorld;
CBackgroundPainter::Instance().RotateSB(&matWorld);
}
}
}
public aiVector3D SymMul(aiVector3D o) {
aiVector3D ret = new aiVector3D(AssimpPINVOKE.aiVector3D_SymMul(swigCPtr, aiVector3D.getCPtr(o)), true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
internal static HandleRef getCPtr(aiVector3D obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
public aiVectorKey(double time, aiVector3D value) : this(AssimpPINVOKE.new_aiVectorKey__SWIG_1(time, aiVector3D.getCPtr(value)), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
private void ApplyAssimpConfiguration(Importer importer, Property.Data data)
{
if (data.isStepFlag)
{
bool value_step;
if (Boolean.TryParse(data.currentValue, out value_step))
{
importer.Assimp.ChangeFlag(data.processStep, value_step);
}
}
else
{
switch (data.propertyType)
{
case Property.Type.BOOL:
bool?value_bool = Property.Data.GetBool(data);
if (value_bool.HasValue)
{
importer.Assimp.SetProperty(data.propertyFlag, value_bool.Value);
}
break;
case Property.Type.FLAG:
case Property.Type.INT:
int?value_int = Property.Data.GetInt(data);
if (value_int.HasValue)
{
importer.Assimp.SetProperty(data.propertyFlag, value_int.Value);
}
break;
case Property.Type.FLOAT:
float?value_float = Property.Data.GetFloat(data);
if (value_float.HasValue)
{
importer.Assimp.SetProperty(data.propertyFlag, value_float.Value);
}
break;
case Property.Type.STRING:
importer.Assimp.SetProperty(data.propertyFlag, data.currentValue);
break;
case Property.Type.MATRIX:
const int size = 9;
List <string> values_matrix_str = UI.List.Parse(data.currentValue);
if (values_matrix_str.Count == size)
{
float[] value_matrix = new float[size];
for (int i = 0; i < size; i++)
{
if (!float.TryParse(values_matrix_str[i], out value_matrix[i]))
{
Debug.LogWarning("Invalid value \"" + data.optionText + " = " + values_matrix_str[i] + "\": should be a float.");
}
}
Vector3 pos = new Vector3(value_matrix[0], value_matrix[1], value_matrix[2]);
Quaternion rot = new Quaternion();
rot.eulerAngles = new Vector3(value_matrix[3], value_matrix[4], value_matrix[5]);
Vector3 scale = new Vector3(value_matrix[6], value_matrix[7], value_matrix[8]);
using (aiVector3D scaling = Type.Assimp.Convert.UnityToAssimp.Vector3(scale))
{
using (aiQuaternion rotation = Type.Assimp.Convert.UnityToAssimp.Quaternion(rot))
{
using (aiVector3D position = Type.Assimp.Convert.UnityToAssimp.Vector3(pos))
{
using (aiMatrix4x4 matrix = new aiMatrix4x4(scaling, rotation, position))
{
importer.Assimp.SetProperty(data.propertyFlag, matrix);
}
}
}
}
}
break;
default:
break;
}
}
}
public static aiMatrix4x4 FromToMatrix(aiVector3D from, aiVector3D to, aiMatrix4x4 arg2) {
aiMatrix4x4 ret = new aiMatrix4x4(AssimpPINVOKE.aiMatrix4x4_FromToMatrix(aiVector3D.getCPtr(from), aiVector3D.getCPtr(to), aiMatrix4x4.getCPtr(arg2)), false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public aiVector3D __divnset__(float f) {
aiVector3D ret = new aiVector3D(AssimpPINVOKE.aiVector3D___divnset__(swigCPtr, f), false);
return ret;
}
public aiVector3D Normalize() {
aiVector3D ret = new aiVector3D(AssimpPINVOKE.aiVector3D_Normalize(swigCPtr), false);
return ret;
}
public aiVector3D(aiVector3D o) : this(AssimpPINVOKE.new_aiVector3D__SWIG_3(aiVector3D.getCPtr(o)), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiRay(aiVector3D _pos, aiVector3D _dir)
: this(AssimpPINVOKE.new_aiRay__SWIG_1(aiVector3D.getCPtr(_pos), aiVector3D.getCPtr(_dir)), true)
{
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiVector3D __subnset__(aiVector3D o) {
aiVector3D ret = new aiVector3D(AssimpPINVOKE.aiVector3D___subnset__(swigCPtr, aiVector3D.getCPtr(o)), false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static aiMatrix4x4 Scaling(aiVector3D v, aiMatrix4x4 arg1) {
aiMatrix4x4 ret = new aiMatrix4x4(AssimpPINVOKE.aiMatrix4x4_Scaling(aiVector3D.getCPtr(v), aiMatrix4x4.getCPtr(arg1)), false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static aiMatrix4x4 Rotation(float a, aiVector3D axis, aiMatrix4x4 arg2) {
aiMatrix4x4 ret = new aiMatrix4x4(AssimpPINVOKE.aiMatrix4x4_Rotation(a, aiVector3D.getCPtr(axis), aiMatrix4x4.getCPtr(arg2)), false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public aiVector3D __mulnset__(aiMatrix4x4 mat) {
aiVector3D ret = new aiVector3D(AssimpPINVOKE.aiVector3D___mulnset____SWIG_2(swigCPtr, aiMatrix4x4.getCPtr(mat)), false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public aiQuaternion(aiVector3D normalized) : this(AssimpPINVOKE.new_aiQuaternion__SWIG_5(aiVector3D.getCPtr(normalized)), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public bool __equal__(aiVector3D other) {
bool ret = AssimpPINVOKE.aiVector3D___equal__(swigCPtr, aiVector3D.getCPtr(other));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public void DecomposeNoScaling(aiQuaternion rotation, aiVector3D position) {
AssimpPINVOKE.aiMatrix4x4_DecomposeNoScaling(swigCPtr, aiQuaternion.getCPtr(rotation), aiVector3D.getCPtr(position));
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
public aiVector3D Rotate(aiVector3D arg0) {
aiVector3D ret = new aiVector3D(AssimpPINVOKE.aiQuaternion_Rotate(swigCPtr, aiVector3D.getCPtr(arg0)), true);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public aiMatrix4x4 FromEulerAnglesXYZ(aiVector3D blubb) {
aiMatrix4x4 ret = new aiMatrix4x4(AssimpPINVOKE.aiMatrix4x4_FromEulerAnglesXYZ__SWIG_1(swigCPtr, aiVector3D.getCPtr(blubb)), false);
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public aiQuaternion(aiVector3D axis, float angle) : this(AssimpPINVOKE.new_aiQuaternion__SWIG_4(aiVector3D.getCPtr(axis), angle), true) {
if (AssimpPINVOKE.SWIGPendingException.Pending) throw AssimpPINVOKE.SWIGPendingException.Retrieve();
}
