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); }
static void Main(string[] args) { //创建线程 //BaseThread.CreateThread(); //线程休眠 //BaseThread.SleepThread(); //线程等待 //BaseThread.AwaitThread(); //中止线程core的控制台不支持 //BaseThread.AbortThread(); //检查线程状态 //BaseThread.CheckThreadState(); //线程优先级 //BaseThread.SetThreadPriority(); //前台线程和后台线程 //BaseThread.qahThread(); //向线程传递参数 //BaseThread.PassThread(); //lock线程锁 //BaseThread.LockThread(); //MonitorThread锁 //BaseThread.MonitorThread(); //异常处理 BaseThread.TryErrorThread(); }
public BaseThread Get() { global::System.IntPtr cPtr = C4dApiPINVOKE.C4DThread_Get(swigCPtr); BaseThread ret = (cPtr == global::System.IntPtr.Zero) ? null : new BaseThread(cPtr, false); 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 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 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 void CloseThread(string threadName) { Dictionary <String, ThreadInfo> thread_pool = LTCingFWSet.ThreadPool; if (thread_pool.Keys.Contains(threadName)) { BaseThread rth = (BaseThread)thread_pool[threadName].ContextObject; rth.IsOpen = false; thread_pool.Remove(threadName); } }
internal void OnStatementExecuted(object t, ExecutionQueryEvent e) { StatementExecuted?.Invoke(t, e); if (e.Status != Status.RUNNING && this.queryThread != null) { lock (this.queryThread) { this.queryThread.StatementExecuted -= OnStatementExecuted; this.queryThread = null; } } }
static void Main(string[] args) { //创建线程 //BaseThread.CreateThread(); //线程休眠 //BaseThread.SleepThread(); //线程等待 //BaseThread.AwaitThread(); //中止线程core的控制台不支持 //BaseThread.AbortThread(); //检查线程状态 BaseThread.CheckThreadState(); }
internal void Execute(List <string> statements, DbConnection con, QueryParams qp, bool contExecutingOnFail) { if (this.queryThread == null) { this.queryThread = new ExecutorThread() { ContinueExecutingNextOnFail = contExecutingOnFail }; lock (this.queryThread) { this.queryThread.StatementExecuted += OnStatementExecuted; this.queryThread.Start(statements, con, qp); } } }
internal void Abort() { if (this.queryThread != null) { var queryParams = this.queryThread.QueryParams; string query = this.queryThread.CurrentQuery; lock (this.queryThread) { this.queryThread.StatementExecuted -= OnStatementExecuted; this.queryThread.Abort(); this.queryThread = null; } StatementExecuted?.Invoke(this, new ExecutionQueryEvent(Status.ABORTED) { QueryParams = queryParams, TAG = queryParams.Hash, query = query }); } }
public void SetData(BossMonster boss, IEntity FixedTarget) { if (FixedTarget != null) { this.FixedTarget = FixedTarget; } this.BossMob = boss; ProtectedPlayers = boss.ProtectedPlayers; AttackThread = new BaseThread(Creature_Attack_Thread, 500, ""); AttackThread.Start(); MoveThread = new BaseThread(Creature_Move_Thread, 500, ""); MoveThread.Start(); CanRevive = false; this.BossMob.Creatures.TryAdd(EntityUID, this); }
public static void OpenThread(BaseThread threadContext, string threadName, object param) { Dictionary <String, ThreadInfo> thread_pool = LTCingFWSet.ThreadPool; if (thread_pool.Keys.Contains(threadName)) { BaseThread rth = (BaseThread)thread_pool[threadName].ContextObject; rth.IsOpen = true; } else { threadContext.IsOpen = true; Thread thd = new Thread(new ParameterizedThreadStart(threadContext.run)); thd.IsBackground = true; thd.Name = threadName; thd.Start(param); ThreadInfo tinfo = new ThreadInfo(thd, threadContext); thread_pool.Add(threadName, tinfo); } }
public static bool ThreadisLiving(string threadName) { Dictionary <String, ThreadInfo> thread_pool = LTCingFWSet.ThreadPool; if (thread_pool.Keys.Contains(threadName)) { BaseThread rth = (BaseThread)thread_pool[threadName].ContextObject; if (rth.IsOpen == true) { return(true); } else { return(false); } } else { return(false); } }
public override int GetHashCode() { return(BaseThread.GetHashCode()); }
public GvError Execute2(BaseThread thread, GvCalcFlags flags) { GvError ret = (GvError)C4dApiPINVOKE.GvNodeMaster_Execute2(swigCPtr, BaseThread.getCPtr(thread), (int)flags); return(ret); }
public GvError Execute(BaseThread thread) { GvError ret = (GvError)C4dApiPINVOKE.GvNodeMaster_Execute(swigCPtr, BaseThread.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 GvError QueryCalculation(GvQuery query, BaseThread thread) { GvError ret = (GvError)C4dApiPINVOKE.GvNodeMaster_QueryCalculation(swigCPtr, GvQuery.getCPtr(query), BaseThread.getCPtr(thread)); return(ret); }
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(BaseThread obj) { return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr); }
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 override bool Equals(object?obj) { return(obj is ThreadWrapper other && BaseThread.Equals(other.BaseThread)); }
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 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 override SplineObject GetContour(BaseObject op, BaseDocument doc, double lod, BaseThread bt) { BaseContainer bc = op.GetDataInstance(); SplineObject bp = GenerateCircle(bc.GetFloat(CIRCLEOBJECT_RAD)); if (bp == null) { return(null); } BaseContainer bb = bp.GetDataInstance(); bb.SetInt32(C4dApi.SPLINEOBJECT_INTERPOLATION, bc.GetInt32(C4dApi.SPLINEOBJECT_INTERPOLATION)); bb.SetInt32(C4dApi.SPLINEOBJECT_SUB, bc.GetInt32(C4dApi.SPLINEOBJECT_SUB)); bb.SetFloat(C4dApi.SPLINEOBJECT_ANGLE, bc.GetFloat(C4dApi.SPLINEOBJECT_ANGLE)); bb.SetFloat(C4dApi.SPLINEOBJECT_MAXIMUMLENGTH, bc.GetFloat(C4dApi.SPLINEOBJECT_MAXIMUMLENGTH)); OrientObject(bp, bc.GetInt32(C4dApi.PRIM_PLANE), bc.GetBool(C4dApi.PRIM_REVERSE)); return(bp); }
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 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 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 Lock(BaseThread bt) { bool ret = C4dApiPINVOKE.Semaphore_Lock__SWIG_0(swigCPtr, 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); }