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);
}
