示例#1
0
        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);
        }
示例#2
0
        public GvError QueryCalculation(GvQuery query, BaseThread thread)
        {
            GvError ret = (GvError)C4dApiPINVOKE.GvNodeMaster_QueryCalculation(swigCPtr, GvQuery.getCPtr(query), BaseThread.getCPtr(thread));

            return(ret);
        }
示例#3
0
 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 */
 }
示例#4
0
        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);
        }
示例#5
0
        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);
        }
示例#6
0
        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);
        }
示例#7
0
        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);
        }
示例#8
0
        public GvError Execute2(BaseThread thread, GvCalcFlags flags)
        {
            GvError ret = (GvError)C4dApiPINVOKE.GvNodeMaster_Execute2(swigCPtr, BaseThread.getCPtr(thread), (int)flags);

            return(ret);
        }
示例#9
0
        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);
        }
示例#10
0
 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 */
 }
示例#11
0
        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);
        }
示例#12
0
        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);
        }
示例#13
0
        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);
        }
示例#14
0
        public GvError InitCalculation(GvInit init, BaseThread thread)
        {
            GvError ret = (GvError)C4dApiPINVOKE.GvNodeMaster_InitCalculation(swigCPtr, GvInit.getCPtr(init), BaseThread.getCPtr(thread));

            return(ret);
        }
示例#15
0
        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);
        }
示例#16
0
        public GvError Execute(BaseThread thread)
        {
            GvError ret = (GvError)C4dApiPINVOKE.GvNodeMaster_Execute(swigCPtr, BaseThread.getCPtr(thread));

            return(ret);
        }
示例#17
0
        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);
        }
示例#18
0
        public bool Lock(BaseThread bt)
        {
            bool ret = C4dApiPINVOKE.Semaphore_Lock__SWIG_0(swigCPtr, BaseThread.getCPtr(bt));

            return(ret);
        }
示例#19
0
        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);
        }