public virtual bool ModifyObject(BaseObject mod, BaseDocument doc, BaseObject op, ref Fusee.Math.Core.Matrix4D /* constMatrix&_cstype */ op_mg, ref Fusee.Math.Core.Matrix4D /* constMatrix&_cstype */ mod_mg, double lod, int flags, BaseThread thread) {
double[] adbl_op_mg;
unsafe {adbl_op_mg = Fusee.Math.ArrayConversion.Convert.Matrix4DToArrayDoubleC4DLayout(op_mg); fixed (double *pdbl_op_mg = adbl_op_mg) {
/* constMatrix&_csin_pre */
double[] adbl_mod_mg;
unsafe {adbl_mod_mg = Fusee.Math.ArrayConversion.Convert.Matrix4DToArrayDoubleC4DLayout(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), (IntPtr) pdbl_op_mg /* constMatrix&_csin */, (IntPtr) pdbl_mod_mg /* constMatrix&_csin */, lod, flags, BaseThread.getCPtr(thread));
return ret;
} finally {
// NOP op_mg = Fusee.Math.ArrayConversion.Convert.ArrayDoubleC4DLayoutToMatrix4D(pdbl_op_mg);
/* constMatrix&_csin_post */
// NOP mod_mg = Fusee.Math.ArrayConversion.Convert.ArrayDoubleC4DLayoutToMatrix4D(pdbl_mod_mg);
/* constMatrix&_csin_post */
}
} } /* constMatrix&_csin_terminator */
} } /* constMatrix&_csin_terminator */
}
public bool Lock(BaseThread bt) {
bool ret = C4dApiPINVOKE.Semaphore_Lock__SWIG_0(swigCPtr, BaseThread.getCPtr(bt));
return ret;
}
internal static HandleRef getCPtr(BaseThread obj) {
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
public static THREADTYPE IdentifyThread(BaseThread bt) {
THREADTYPE ret = (THREADTYPE)C4dApiPINVOKE.IdentifyThread(BaseThread.getCPtr(bt));
return ret;
}
public LineObject GetLineObject(BaseDocument doc, double lod, BaseThread thread) {
IntPtr cPtr = C4dApiPINVOKE.SplineObject_GetLineObject__SWIG_0(swigCPtr, BaseDocument.getCPtr(doc), lod, BaseThread.getCPtr(thread));
LineObject ret = (cPtr == IntPtr.Zero) ? null : new LineObject(cPtr, false);
return ret;
}
public static void StartEditorRender(bool active_only, bool raybrush, int x1, int y1, int x2, int y2, BaseThread bt, BaseDraw bd, bool newthread) {
C4dApiPINVOKE.StartEditorRender(active_only, raybrush, x1, y1, x2, y2, BaseThread.getCPtr(bt), BaseDraw.getCPtr(bd), newthread);
}
public static SWIGTYPE_p_IpConnection GeIpOpenOutgoing(SWIGTYPE_p_CHAR hostname, BaseThread thread, int initial_timeout, int timeout, bool dontwait, SWIGTYPE_p_LONG ferr) {
IntPtr cPtr = C4dApiPINVOKE.GeIpOpenOutgoing(SWIGTYPE_p_CHAR.getCPtr(hostname), BaseThread.getCPtr(thread), initial_timeout, timeout, dontwait, SWIGTYPE_p_LONG.getCPtr(ferr));
SWIGTYPE_p_IpConnection ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_IpConnection(cPtr, false);
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 GvError Execute(BaseThread thread) {
GvError ret = (GvError)C4dApiPINVOKE.GvNodeMaster_Execute(swigCPtr, BaseThread.getCPtr(thread));
return ret;
}
public bool TriangulateRelease(ref Fusee.Math.Core.Vector3D /* Vector*&_cstype */ pvPoints, int lPointCount, SWIGTYPE_p_LONG plSegments, int lSegCnt, SWIGTYPE_p_p_CPolygon pPolys, SWIGTYPE_p_LONG lPolyCount, int lFlags, SWIGTYPE_p_LONG plMap, BaseThread pThread) {
bool ret = C4dApiPINVOKE.PolyTriangulate_TriangulateRelease__SWIG_2(swigCPtr, ref pvPoints /* Vector*&_csin */, lPointCount, SWIGTYPE_p_LONG.getCPtr(plSegments), lSegCnt, SWIGTYPE_p_p_CPolygon.getCPtr(pPolys), SWIGTYPE_p_LONG.getCPtr(lPolyCount), lFlags, SWIGTYPE_p_LONG.getCPtr(plMap), BaseThread.getCPtr(pThread));
if (C4dApiPINVOKE.SWIGPendingException.Pending) throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
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 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;
}
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 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 static bool MergeDocument(BaseDocument doc, SWIGTYPE_p_Filename name, SCENEFILTER loadflags, BaseThread thread) {
bool ret = C4dApiPINVOKE.MergeDocument(BaseDocument.getCPtr(doc), SWIGTYPE_p_Filename.getCPtr(name), (int)loadflags, BaseThread.getCPtr(thread));
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 static RENDERRESULT RenderDocument(BaseDocument doc, BaseContainer rdata, SWIGTYPE_p_ProgressHook pr, SWIGTYPE_p_void private_data, BaseBitmap bmp, RENDERFLAGS renderflags, BaseThread th) {
RENDERRESULT ret = (RENDERRESULT)C4dApiPINVOKE.RenderDocument(BaseDocument.getCPtr(doc), BaseContainer.getCPtr(rdata), SWIGTYPE_p_ProgressHook.getCPtr(pr), SWIGTYPE_p_void.getCPtr(private_data), BaseBitmap.getCPtr(bmp), (int)renderflags, BaseThread.getCPtr(th));
if (C4dApiPINVOKE.SWIGPendingException.Pending) throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static BaseObject GenerateSplinePrimitive(BaseDocument doc, int type, BaseContainer bc, double lod, BaseThread bt) {
IntPtr cPtr = C4dApiPINVOKE.GenerateSplinePrimitive__SWIG_0(BaseDocument.getCPtr(doc), type, BaseContainer.getCPtr(bc), lod, BaseThread.getCPtr(bt));
BaseObject ret = (cPtr == IntPtr.Zero) ? null : new BaseObject(cPtr, false);
if (C4dApiPINVOKE.SWIGPendingException.Pending) throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static SWIGTYPE_p_IpConnection GeIpOpenListener(SWIGTYPE_p_ULONG ipAddr, int port, BaseThread thread, int timeout, bool dontwait, SWIGTYPE_p_LONG ferr) {
IntPtr cPtr = C4dApiPINVOKE.GeIpOpenListener(SWIGTYPE_p_ULONG.getCPtr(ipAddr), port, BaseThread.getCPtr(thread), timeout, dontwait, SWIGTYPE_p_LONG.getCPtr(ferr));
SWIGTYPE_p_IpConnection ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_IpConnection(cPtr, false);
if (C4dApiPINVOKE.SWIGPendingException.Pending) throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static SplineObject FitCurve(ref Fusee.Math.Core.Vector3D /* Vector*&_cstype */ padr, int pcnt, double error, BaseThread bt) {
IntPtr cPtr = C4dApiPINVOKE.FitCurve(ref padr /* Vector*&_csin */, pcnt, error, BaseThread.getCPtr(bt));
SplineObject ret = (cPtr == IntPtr.Zero) ? null : new SplineObject(cPtr, false);
return ret;
}
public static SWIGTYPE_p_IpConnection GeIpWaitForIncoming(SWIGTYPE_p_IpConnection listener, BaseThread connection, SWIGTYPE_p_LONG ferr) {
IntPtr cPtr = C4dApiPINVOKE.GeIpWaitForIncoming(SWIGTYPE_p_IpConnection.getCPtr(listener), BaseThread.getCPtr(connection), SWIGTYPE_p_LONG.getCPtr(ferr));
SWIGTYPE_p_IpConnection ret = (cPtr == IntPtr.Zero) ? null : new SWIGTYPE_p_IpConnection(cPtr, false);
return ret;
}
public static bool TriangulateStandard(ref Fusee.Math.Core.Vector3D /* Vector*&_cstype */ padr, int pcnt, SWIGTYPE_p_LONG list, int lcnt, SWIGTYPE_p_p_CPolygon vadr, SWIGTYPE_p_LONG vcnt, BaseThread thread) {
bool ret = C4dApiPINVOKE.TriangulateStandard(ref padr /* Vector*&_csin */, pcnt, SWIGTYPE_p_LONG.getCPtr(list), lcnt, SWIGTYPE_p_p_CPolygon.getCPtr(vadr), SWIGTYPE_p_LONG.getCPtr(vcnt), BaseThread.getCPtr(thread));
if (C4dApiPINVOKE.SWIGPendingException.Pending) throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public override SplineObject GetContour(BaseObject op, BaseDocument doc, double lod, BaseThread bt)
{
BaseContainer bc = op.GetDataInstance();
SplineObject bp = GenerateCircle(bc.GetReal(CIRCLEOBJECT_RAD));
if (bp == null)
return null;
BaseContainer bb = bp.GetDataInstance();
bb.SetLong(C4dApi.SPLINEOBJECT_INTERPOLATION, bc.GetLong(C4dApi.SPLINEOBJECT_INTERPOLATION));
bb.SetLong(C4dApi.SPLINEOBJECT_SUB, bc.GetLong(C4dApi.SPLINEOBJECT_SUB));
bb.SetReal(C4dApi.SPLINEOBJECT_ANGLE, bc.GetReal(C4dApi.SPLINEOBJECT_ANGLE));
bb.SetReal(C4dApi.SPLINEOBJECT_MAXIMUMLENGTH, bc.GetReal(C4dApi.SPLINEOBJECT_MAXIMUMLENGTH));
OrientObject(bp, bc.GetLong(C4dApi.PRIM_PLANE), bc.GetBool(C4dApi.PRIM_REVERSE));
return bp;
}
public static bool TriangulateRegular(ref Fusee.Math.Core.Vector3D /* Vector*&_cstype */ pinp, int pinp_cnt, SWIGTYPE_p_LONG list, int lcnt, SWIGTYPE_p_p_Vector padr, SWIGTYPE_p_LONG pcnt, SWIGTYPE_p_p_CPolygon vadr, SWIGTYPE_p_LONG vcnt, double regular_width, BaseThread thread) {
bool ret = C4dApiPINVOKE.TriangulateRegular(ref pinp /* Vector*&_csin */, pinp_cnt, SWIGTYPE_p_LONG.getCPtr(list), lcnt, SWIGTYPE_p_p_Vector.getCPtr(padr), SWIGTYPE_p_LONG.getCPtr(pcnt), SWIGTYPE_p_p_CPolygon.getCPtr(vadr), SWIGTYPE_p_LONG.getCPtr(vcnt), regular_width, BaseThread.getCPtr(thread));
if (C4dApiPINVOKE.SWIGPendingException.Pending) throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
} /* </String_csout> */
public virtual bool SceneDraw(GvNode bn, BaseDraw bd, BaseDrawHelp bh, BaseThread bt, int flags, SWIGTYPE_p_void data, SWIGTYPE_p_ULONG 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), SWIGTYPE_p_ULONG.getCPtr(counter));
if (C4dApiPINVOKE.SWIGPendingException.Pending) throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public static BaseObject GenerateText(BaseContainer cp, BaseThread bt, bool separate) {
IntPtr cPtr = C4dApiPINVOKE.GenerateText(BaseContainer.getCPtr(cp), BaseThread.getCPtr(bt), separate);
BaseObject ret = (cPtr == IntPtr.Zero) ? null : new BaseObject(cPtr, false);
return ret;
}
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 static BaseDocument LoadDocument(SWIGTYPE_p_Filename name, SCENEFILTER loadflags, BaseThread thread) {
IntPtr cPtr = C4dApiPINVOKE.LoadDocument(SWIGTYPE_p_Filename.getCPtr(name), (int)loadflags, BaseThread.getCPtr(thread));
BaseDocument ret = (cPtr == IntPtr.Zero) ? null : new BaseDocument(cPtr, false);
if (C4dApiPINVOKE.SWIGPendingException.Pending) throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
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 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;
}
