public virtual EXECUTIONRESULT Execute(BaseObject op, BaseDocument doc, BaseThread bt, int priority, EXECUTIONFLAGS flags)
{
EXECUTIONRESULT ret = (EXECUTIONRESULT)C4dApiPINVOKE.ObjectData_Execute(swigCPtr, BaseObject.getCPtr(op), BaseDocument.getCPtr(doc), BaseThread.getCPtr(bt), priority, (int)flags);
return(ret);
}
public GvError QueryCalculation(GvQuery query, BaseThread thread)
{
GvError ret = (GvError)C4dApiPINVOKE.GvNodeMaster_QueryCalculation(swigCPtr, GvQuery.getCPtr(query), BaseThread.getCPtr(thread));
return(ret);
}
public virtual bool ModifyObject(BaseObject mod, BaseDocument doc, BaseObject op, ref Fusee.Math.Core.double4x4 /* constMatrix&_cstype */ op_mg, ref Fusee.Math.Core.double4x4 /* constMatrix&_cstype */ mod_mg, double lod, int flags, BaseThread thread)
{
double[] adbl_op_mg;
unsafe { adbl_op_mg = Fusee.Math.ArrayConvert.double4x4ToArrayDoubleC4DLayout(op_mg); fixed(double *pdbl_op_mg = adbl_op_mg)
{
/* constMatrix&_csin_pre */
double[] adbl_mod_mg;
unsafe { adbl_mod_mg = Fusee.Math.ArrayConvert.double4x4ToArrayDoubleC4DLayout(mod_mg); fixed(double *pdbl_mod_mg = adbl_mod_mg)
{
/* constMatrix&_csin_pre */
try {
bool ret = C4dApiPINVOKE.ObjectData_ModifyObject(swigCPtr, BaseObject.getCPtr(mod), BaseDocument.getCPtr(doc), BaseObject.getCPtr(op), (global::System.IntPtr)pdbl_op_mg /* constMatrix&_csin */, (global::System.IntPtr)pdbl_mod_mg /* constMatrix&_csin */, lod, flags, BaseThread.getCPtr(thread));
return(ret);
} finally {
// NOP op_mg = Fusee.Math.ArrayConvert.ArrayDoubleC4DLayoutTodouble4x4(pdbl_op_mg);
/* constMatrix&_csin_post */
// NOP mod_mg = Fusee.Math.ArrayConvert.ArrayDoubleC4DLayoutTodouble4x4(pdbl_mod_mg);
/* constMatrix&_csin_post */
}
}
} /* constMatrix&_csin_terminator */
}
} /* constMatrix&_csin_terminator */
}
public virtual SplineObject GetContour(BaseObject op, BaseDocument doc, double lod, BaseThread bt)
{
global::System.IntPtr cPtr = C4dApiPINVOKE.ObjectData_GetContour(swigCPtr, BaseObject.getCPtr(op), BaseDocument.getCPtr(doc), lod, BaseThread.getCPtr(bt));
SplineObject ret = (cPtr == global::System.IntPtr.Zero) ? null : new SplineObject(cPtr, false);
return(ret);
}
public bool Run(BaseDocument doc, bool spheres, double lod, bool uselod, BUILDFLAGS flags, SWIGTYPE_p_void startdata, BaseThread bt)
{
bool ret = C4dApiPINVOKE.Hierarchy_Run(swigCPtr, BaseDocument.getCPtr(doc), spheres, lod, uselod, (int)flags, SWIGTYPE_p_void.getCPtr(startdata), BaseThread.getCPtr(bt));
return(ret);
}
public LineObject GetLineObject(BaseDocument doc, double lod, BaseThread thread)
{
global::System.IntPtr cPtr = C4dApiPINVOKE.SplineObject_GetLineObject__SWIG_0(swigCPtr, BaseDocument.getCPtr(doc), lod, BaseThread.getCPtr(thread));
LineObject ret = (cPtr == global::System.IntPtr.Zero) ? null : new LineObject(cPtr, false);
return(ret);
}
public virtual FILEERROR Load(BaseSceneLoader node, Filename name, BaseDocument doc, SCENEFILTER filterflags, SWIGTYPE_p_String error, BaseThread bt)
{
FILEERROR ret = (FILEERROR)C4dApiPINVOKE.SceneLoaderData_Load(swigCPtr, BaseSceneLoader.getCPtr(node), Filename.getCPtr(name), BaseDocument.getCPtr(doc), (int)filterflags, SWIGTYPE_p_String.getCPtr(error), BaseThread.getCPtr(bt));
if (C4dApiPINVOKE.SWIGPendingException.Pending)
{
throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public GvError Execute2(BaseThread thread, GvCalcFlags flags)
{
GvError ret = (GvError)C4dApiPINVOKE.GvNodeMaster_Execute2(swigCPtr, BaseThread.getCPtr(thread), (int)flags);
return(ret);
}
public virtual bool InitTool(BaseDocument doc, BaseContainer data, BaseThread bt)
{
bool ret = (SwigDerivedClassHasMethod("InitTool", swigMethodTypes0) ? C4dApiPINVOKE.BrushToolData_InitToolSwigExplicitBrushToolData(swigCPtr, BaseDocument.getCPtr(doc), BaseContainer.getCPtr(data), BaseThread.getCPtr(bt)) : C4dApiPINVOKE.BrushToolData_InitTool(swigCPtr, BaseDocument.getCPtr(doc), BaseContainer.getCPtr(data), BaseThread.getCPtr(bt)));
if (C4dApiPINVOKE.SWIGPendingException.Pending)
{
throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public virtual bool GetModifiedObjects(BaseTag tag, BaseDocument doc, SWIGTYPE_p_p_BaseObject op, SWIGTYPE_p_Bool pluginownedop, ref Fusee.Math.Core.double4x4 /* constMatrix&_cstype */ op_mg, double lod, int flags, BaseThread thread)
{
double[] adbl_op_mg;
unsafe { adbl_op_mg = Fusee.Math.ArrayConvert.double4x4ToArrayDoubleC4DLayout(op_mg); fixed(double *pdbl_op_mg = adbl_op_mg)
{
/* constMatrix&_csin_pre */
try {
bool ret = C4dApiPINVOKE.TagData_GetModifiedObjects(swigCPtr, BaseTag.getCPtr(tag), BaseDocument.getCPtr(doc), SWIGTYPE_p_p_BaseObject.getCPtr(op), SWIGTYPE_p_Bool.getCPtr(pluginownedop), (global::System.IntPtr)pdbl_op_mg /* constMatrix&_csin */, lod, flags, BaseThread.getCPtr(thread));
if (C4dApiPINVOKE.SWIGPendingException.Pending)
{
throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
} finally {
// NOP op_mg = Fusee.Math.ArrayConvert.ArrayDoubleC4DLayoutTodouble4x4(pdbl_op_mg);
/* constMatrix&_csin_post */
}
}
} /* constMatrix&_csin_terminator */
}
public bool InitTool(BaseDocument doc, BaseContainer data, BaseThread bt, BrushToolData tool)
{
bool ret = C4dApiPINVOKE.BrushBase_InitTool(swigCPtr, BaseDocument.getCPtr(doc), BaseContainer.getCPtr(data), BaseThread.getCPtr(bt), BrushToolData.getCPtr(tool));
if (C4dApiPINVOKE.SWIGPendingException.Pending)
{
throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public virtual bool SceneDraw(GvNode bn, BaseDraw bd, BaseDrawHelp bh, BaseThread bt, int flags, SWIGTYPE_p_void data, uint counter)
{
bool ret = C4dApiPINVOKE.GvOperatorData_SceneDraw(swigCPtr, GvNode.getCPtr(bn), BaseDraw.getCPtr(bd), BaseDrawHelp.getCPtr(bh), BaseThread.getCPtr(bt), flags, SWIGTYPE_p_void.getCPtr(data), counter);
return(ret);
}
public bool Init(BaseThread parent, int count, SWIGTYPE_p_p_C4DThread thread)
{
bool ret = C4dApiPINVOKE.MPThreadPool_Init__SWIG_0(swigCPtr, BaseThread.getCPtr(parent), count, SWIGTYPE_p_p_C4DThread.getCPtr(thread));
return(ret);
}
public GvError InitCalculation(GvInit init, BaseThread thread)
{
GvError ret = (GvError)C4dApiPINVOKE.GvNodeMaster_InitCalculation(swigCPtr, GvInit.getCPtr(init), BaseThread.getCPtr(thread));
return(ret);
}
public bool Triangulate(ref Fusee.Math.Core.double3 /* Vector*&_cstype */ pvPoints, int lPointCount, SWIGTYPE_p_Int32 plSegments, int lSegCnt, SWIGTYPE_p_p_CPolygon pPolys, SWIGTYPE_p_Int32 lPolyCount, int lFlags, SWIGTYPE_p_Int32 plMap, BaseThread pThread)
{
bool ret = C4dApiPINVOKE.PolyTriangulate_Triangulate__SWIG_2(swigCPtr, ref pvPoints /* Vector*&_csin */, lPointCount, SWIGTYPE_p_Int32.getCPtr(plSegments), lSegCnt, SWIGTYPE_p_p_CPolygon.getCPtr(pPolys), SWIGTYPE_p_Int32.getCPtr(lPolyCount), lFlags, SWIGTYPE_p_Int32.getCPtr(plMap), BaseThread.getCPtr(pThread));
if (C4dApiPINVOKE.SWIGPendingException.Pending)
{
throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public GvError Execute(BaseThread thread)
{
GvError ret = (GvError)C4dApiPINVOKE.GvNodeMaster_Execute(swigCPtr, BaseThread.getCPtr(thread));
return(ret);
}
public PolygonObject Triangulate(double regular, BaseThread bt)
{
global::System.IntPtr cPtr = C4dApiPINVOKE.LineObject_Triangulate(swigCPtr, regular, BaseThread.getCPtr(bt));
PolygonObject ret = (cPtr == global::System.IntPtr.Zero) ? null : new PolygonObject(cPtr, false);
return(ret);
}
public bool Lock(BaseThread bt)
{
bool ret = C4dApiPINVOKE.Semaphore_Lock__SWIG_0(swigCPtr, BaseThread.getCPtr(bt));
return(ret);
}
public bool ExecutePasses(BaseThread bt, bool animation, bool expressions, bool caches, BUILDFLAGS flags)
{
bool ret = C4dApiPINVOKE.BaseDocument_ExecutePasses(swigCPtr, BaseThread.getCPtr(bt), animation, expressions, caches, (int)flags);
return(ret);
}