public GvNode GetTableNode(GvRun run, int id)
{
global::System.IntPtr cPtr = C4dApiPINVOKE.GvCalcTable_GetTableNode(swigCPtr, GvRun.getCPtr(run), id);
GvNode ret = (cPtr == global::System.IntPtr.Zero) ? null : new GvNode(cPtr, false);
return(ret);
}
public GvPort Calculate(GvNode bn, GvRun r, GvCalc c)
{
global::System.IntPtr cPtr = C4dApiPINVOKE.GvPort_Calculate(swigCPtr, GvNode.getCPtr(bn), GvRun.getCPtr(r), GvCalc.getCPtr(c));
GvPort ret = (cPtr == global::System.IntPtr.Zero) ? null : new GvPort(cPtr, false);
return(ret);
}
public GvValue AllocCalculationHandler(int main_id, GvCalc calc, GvRun run, int singleport)
{
global::System.IntPtr cPtr = C4dApiPINVOKE.GvNode_AllocCalculationHandler(swigCPtr, main_id, GvCalc.getCPtr(calc), GvRun.getCPtr(run), singleport);
GvValue ret = (cPtr == global::System.IntPtr.Zero) ? null : new GvValue(cPtr, false);
return(ret);
}
public GvPort CalculateInPortIndex(int port_index, GvRun run, GvCalc calc)
{
global::System.IntPtr cPtr = C4dApiPINVOKE.GvNode_CalculateInPortIndex(swigCPtr, port_index, GvRun.getCPtr(run), GvCalc.getCPtr(calc));
GvPort ret = (cPtr == global::System.IntPtr.Zero) ? null : new GvPort(cPtr, false);
return(ret);
}
public GvPort CalculateOutPort(GvPort port, GvRun run, GvCalc calc)
{
global::System.IntPtr cPtr = C4dApiPINVOKE.GvNode_CalculateOutPort(swigCPtr, GvPort.getCPtr(port), GvRun.getCPtr(run), GvCalc.getCPtr(calc));
GvPort ret = (cPtr == global::System.IntPtr.Zero) ? null : new GvPort(cPtr, false);
return(ret);
}
public GvRun GetRun()
{
global::System.IntPtr cPtr = C4dApiPINVOKE.GvNodeMaster_GetRun(swigCPtr);
GvRun ret = (cPtr == global::System.IntPtr.Zero) ? null : new GvRun(cPtr, false);
return(ret);
}
public bool GetObjectWithIndex(SWIGTYPE_p_p_BaseList2D o, GvRun r)
{
bool ret = C4dApiPINVOKE.GvPort_GetObjectWithIndex__SWIG_1(swigCPtr, SWIGTYPE_p_p_BaseList2D.getCPtr(o), GvRun.getCPtr(r));
if (C4dApiPINVOKE.SWIGPendingException.Pending)
{
throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public bool GetInstance(SWIGTYPE_p_p_BaseList2D i, GvRun r)
{
bool ret = C4dApiPINVOKE.GvPort_GetInstance__SWIG_1(swigCPtr, SWIGTYPE_p_p_BaseList2D.getCPtr(i), GvRun.getCPtr(r));
if (C4dApiPINVOKE.SWIGPendingException.Pending)
{
throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public bool GetMaterial(SWIGTYPE_p_p_BaseList2D m, GvRun r, SWIGTYPE_p_Int32 index)
{
bool ret = C4dApiPINVOKE.GvPort_GetMaterial__SWIG_0(swigCPtr, SWIGTYPE_p_p_BaseList2D.getCPtr(m), GvRun.getCPtr(r), SWIGTYPE_p_Int32.getCPtr(index));
if (C4dApiPINVOKE.SWIGPendingException.Pending)
{
throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public bool SetString(string /* constString&_cstype */ s, GvRun r)
{
bool ret = C4dApiPINVOKE.GvPort_SetString(swigCPtr, s, GvRun.getCPtr(r));
if (C4dApiPINVOKE.SWIGPendingException.Pending)
{
throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public bool SetTime(BaseTime t, GvRun r)
{
bool ret = C4dApiPINVOKE.GvPort_SetTime(swigCPtr, BaseTime.getCPtr(t), GvRun.getCPtr(r));
if (C4dApiPINVOKE.SWIGPendingException.Pending)
{
throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public bool GetDataInstance(SWIGTYPE_p_p_void d, int type, GvRun r)
{
bool ret = C4dApiPINVOKE.GvPort_GetDataInstance(swigCPtr, SWIGTYPE_p_p_void.getCPtr(d), type, GvRun.getCPtr(r));
if (C4dApiPINVOKE.SWIGPendingException.Pending)
{
throw C4dApiPINVOKE.SWIGPendingException.Retrieve();
}
return(ret);
}
public bool GetMatrix(ref Fusee.Math.Core.double4x4 /* Matrix*&_cstype */ m, GvRun r)
{
double[] adbl_m;
unsafe { adbl_m = Fusee.Math.ArrayConvert.double4x4ToArrayDoubleC4DLayout(m); fixed(double *pdbl_m = adbl_m)
{
/* Matrix*&_csin_pre */
try {
bool ret = C4dApiPINVOKE.GvPort_GetMatrix(swigCPtr, (global::System.IntPtr)pdbl_m /* Matrix*&_csin */, GvRun.getCPtr(r));
return(ret);
} finally {
m = Fusee.Math.ArrayConvert.ArrayDoubleC4DLayoutTodouble4x4(pdbl_m);
/* Matrix*&_csin_post */
}
}
} /* Matrix*&_csin_terminator */
}
public bool AddNodeToTable(GvRun run, GvNode node)
{
bool ret = C4dApiPINVOKE.GvCalcTable_AddNodeToTable(swigCPtr, GvRun.getCPtr(run), GvNode.getCPtr(node));
return(ret);
}
public void ResetTable(GvRun run)
{
C4dApiPINVOKE.GvCalcTable_ResetTable(swigCPtr, GvRun.getCPtr(run));
}
public bool CalculateRawDataRev(SWIGTYPE_p_void data, SWIGTYPE_p_void dest, GvRun r, GvValueFlags calculation)
{
bool ret = C4dApiPINVOKE.GvPort_CalculateRawDataRev__SWIG_1(swigCPtr, SWIGTYPE_p_void.getCPtr(data), SWIGTYPE_p_void.getCPtr(dest), GvRun.getCPtr(r), (int)calculation);
return(ret);
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(GvRun obj)
{
return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr);
}
public bool SetRecalculate(GvRun r)
{
bool ret = C4dApiPINVOKE.GvNode_SetRecalculate__SWIG_1(swigCPtr, GvRun.getCPtr(r));
return(ret);
}
public bool SetTag(BaseList2D t, GvRun r)
{
bool ret = C4dApiPINVOKE.GvPort_SetTag__SWIG_1(swigCPtr, BaseList2D.getCPtr(t), GvRun.getCPtr(r));
return(ret);
}
public bool SetMaterial(BaseList2D m, GvRun r)
{
bool ret = C4dApiPINVOKE.GvPort_SetMaterial__SWIG_1(swigCPtr, BaseList2D.getCPtr(m), GvRun.getCPtr(r));
return(ret);
}
public bool SetRecalculate(GvRun r, bool force_set)
{
bool ret = C4dApiPINVOKE.GvNode_SetRecalculate__SWIG_0(swigCPtr, GvRun.getCPtr(r), force_set);
return(ret);
}
public virtual bool SetRecalculate(GvNode bn, GvPort port, GvRun run)
{
bool ret = C4dApiPINVOKE.GvOperatorData_SetRecalculate__SWIG_1(swigCPtr, GvNode.getCPtr(bn), GvPort.getCPtr(port), GvRun.getCPtr(run));
return(ret);
}
public bool SetInstance(BaseList2D i, GvRun r)
{
bool ret = C4dApiPINVOKE.GvPort_SetInstance__SWIG_1(swigCPtr, BaseList2D.getCPtr(i), GvRun.getCPtr(r));
return(ret);
}
public virtual bool AddToCalculationTable(GvNode bn, GvRun run)
{
bool ret = C4dApiPINVOKE.GvOperatorData_AddToCalculationTable(swigCPtr, GvNode.getCPtr(bn), GvRun.getCPtr(run));
return(ret);
}
public bool SetObjectWithIndex(BaseList2D o, GvRun r)
{
bool ret = C4dApiPINVOKE.GvPort_SetObjectWithIndex__SWIG_1(swigCPtr, BaseList2D.getCPtr(o), GvRun.getCPtr(r));
return(ret);
}
public int GetTableCount(GvRun run)
{
int ret = C4dApiPINVOKE.GvCalcTable_GetTableCount(swigCPtr, GvRun.getCPtr(run));
return(ret);
}
public bool Calculate(GvNode node, GvPortIO io, GvRun r, GvCalc c)
{
bool ret = C4dApiPINVOKE.GvValue_Calculate__SWIG_2(swigCPtr, GvNode.getCPtr(node), (int)io, GvRun.getCPtr(r), GvCalc.getCPtr(c));
return(ret);
}
public bool Calculate(GvNode node, GvPortIO io, GvRun r, GvCalc c, int index, BaseTime time)
{
bool ret = C4dApiPINVOKE.GvValue_Calculate__SWIG_0(swigCPtr, GvNode.getCPtr(node), (int)io, GvRun.getCPtr(r), GvCalc.getCPtr(c), index, BaseTime.getCPtr(time));
return(ret);
}
public virtual bool InitCalculation(GvNode bn, GvCalc calc, GvRun run)
{
bool ret = C4dApiPINVOKE.GvOperatorData_InitCalculation(swigCPtr, GvNode.getCPtr(bn), GvCalc.getCPtr(calc), GvRun.getCPtr(run));
return(ret);
}
public virtual bool Calculate(GvNode bn, GvPort port, GvRun run, GvCalc calc)
{
bool ret = C4dApiPINVOKE.GvOperatorData_Calculate(swigCPtr, GvNode.getCPtr(bn), GvPort.getCPtr(port), GvRun.getCPtr(run), GvCalc.getCPtr(calc));
return(ret);
}
