public static extern void gluNurbsCurve_1(
IntPtr nobj,
int nknots,
[In] float[] knot,
int stride,
[In] float[] ctlarray,
int order,
MapTarget type);
public static extern void gluNurbsSurface(
IntPtr nobj,
int sKnotCount,
[In] float[] sKnots,
int tKnotCount,
[In] float[] tKnots,
int sStride,
int tStride,
[In] float[] ctlArray,
int sOrder,
int tOrder,
MapTarget type);
public static void GetnMapARB(MapTarget target, MapQuery query, [Out] int[] v)
{
unsafe
{
fixed(int *p_v = v)
{
Debug.Assert(Delegates.pglGetnMapivARB != null, "pglGetnMapivARB not implemented");
Delegates.pglGetnMapivARB((int)target, (int)query, v.Length, p_v);
LogCommand("glGetnMapivARB", null, target, query, v.Length, v);
}
}
DebugCheckErrors(null);
}
public static void GetnMapARB(MapTarget target, MapQuery query, int bufSize, [Out] double[] v)
{
unsafe
{
fixed(double *p_v = v)
{
Debug.Assert(Delegates.pglGetnMapdvARB != null, "pglGetnMapdvARB not implemented");
Delegates.pglGetnMapdvARB((int)target, (int)query, bufSize, p_v);
LogCommand("glGetnMapdvARB", null, target, query, bufSize, v);
}
}
DebugCheckErrors(null);
}
public static void GetnMapARB(MapTarget target, MapQuery query, Int32 bufSize, [Out] float[] v)
{
unsafe
{
fixed(float *p_v = v)
{
Debug.Assert(Delegates.pglGetnMapfvARB != null, "pglGetnMapfvARB not implemented");
Delegates.pglGetnMapfvARB((Int32)target, (Int32)query, bufSize, p_v);
LogCommand("glGetnMapfvARB", null, target, query, bufSize, v);
}
}
DebugCheckErrors(null);
}
//public static bool ExistCharacter(PalGameObjectBase npc)
//{
// //Dictionary<PalGameObjectBase, MapTarget> characters = CharactersManager.Instance.Characters;
// return characters.ContainsKey(npc);
//}
public static void AddCharacter(PalGameObjectBase npc)
{
Dictionary <PalGameObjectBase, MapTarget> characters = CharactersManager.Instance.Characters;
if (characters.ContainsKey(npc))
{
Debug.LogError("已经在Characters中包含了");
return;
}
MapTarget value = MapTarget.CreateNew(npc);
characters.Add(npc, value);
npc.DestroyEvent = (Action <PalGameObjectBase>)Delegate.Combine(npc.DestroyEvent, new Action <PalGameObjectBase>(CharactersManager.Instance.ObjdestroyEvent));
}
/// <summary>
///
/// </summary>
/// <typeparam name="IComplexType"></typeparam>
/// <param name="maps"></param>
/// <returns></returns>
private static bool IscomplexMapping <IComplexType>(MapTarget maps)
{
return(maps
.target
.GetProperties()
.Any(s => typeof(IComplexType)
.IsAssignableFrom(s.PropertyType))
? true :
maps
.source
.GetProperties()
.Any(s => typeof(IComplexType)
.IsAssignableFrom(s.PropertyType)));
}
internal static extern void glMap1f(MapTarget target, Single u1, Single u2, Int32 stride, Int32 order, Single* points);
internal static extern void glMap2f(MapTarget target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, Single* points);
public static extern void Map1d( MapTarget target, double u1, double u2, int stride, int order, double[] points );
internal static extern void glGetMapiv(MapTarget target, GetMapQuery query, [OutAttribute] Int32* v);
public static void glMap1f(MapTarget target, Single u1, Single u2, Int32 stride, Int32 order, ref Single[] points)
{
i_OpenGL1_0.glMap1f(target, u1, u2, stride, order, ref points);
}
public static extern void Map2f( MapTarget target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float[] points );
internal static extern void glGetMapdv(MapTarget target, GetMapQuery query, [OutAttribute] Double *v);
internal static extern void glMap1f(MapTarget target, Single u1, Single u2, Int32 stride, Int32 order, Single *points);
unsafe void NurbsCurve(IntPtr nurb, Int32 knotCount, [Out] float* knots, Int32 stride, [Out] float* control, Int32 order, MapTarget type)
{
Delegates.gluNurbsCurve((IntPtr)nurb, (Int32)knotCount, (float*)knots, (Int32)stride, (float*)control, (Int32)order, (MapTarget)type);
}
public static void GetMapfv(MapTarget target, GetMapTarget query, float[] v)
{
gl.glGetMapfv((int)target, (int)query, v);
}
public abstract void GetnMap([Flow(FlowDirection.In)] MapTarget target, [Flow(FlowDirection.In)] MapQuery query, [Flow(FlowDirection.In)] uint bufSize, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] Span <int> v);
public abstract unsafe void GetnMap([Flow(FlowDirection.In)] MapTarget target, [Flow(FlowDirection.In)] MapQuery query, [Flow(FlowDirection.In)] uint bufSize, [Count(Parameter = "bufSize"), Flow(FlowDirection.Out)] float *v);
public static void glMap2d(MapTarget target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, ref Double[] points)
{
i_OpenGL1_1.glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, ref points);
}
unsafe void NurbsSurface(IntPtr nurb, Int32 sKnotCount, float* sKnots, Int32 tKnotCount, float* tKnots, Int32 sStride, Int32 tStride, float* control, Int32 sOrder, Int32 tOrder, MapTarget type)
{
Delegates.gluNurbsSurface((IntPtr)nurb, (Int32)sKnotCount, (float*)sKnots, (Int32)tKnotCount, (float*)tKnots, (Int32)sStride, (Int32)tStride, (float*)control, (Int32)sOrder, (Int32)tOrder, (MapTarget)type);
}
internal extern static unsafe void NurbsCurve(IntPtr nurb, Int32 knotCount, [Out] float *knots, Int32 stride, [Out] float *control, Int32 order, MapTarget type);
internal static extern void glGetMapiv(MapTarget target, GetMapQuery query, [OutAttribute] Int32 *v);
internal extern static unsafe void NurbsSurface(IntPtr nurb, Int32 sKnotCount, float *sKnots, Int32 tKnotCount, float *tKnots, Int32 sStride, Int32 tStride, float *control, Int32 sOrder, Int32 tOrder, MapTarget type);
internal static extern void glMap2f(MapTarget target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, Single *points);
public static extern void GetMapdv( MapTarget target, GetMapQuery query, [Out]double[] v );
public static void glGetMapfv(MapTarget target, GetMapQuery query, ref Single[] v)
{
i_OpenGL1_0.glGetMapfv(target, query, ref v);
}
public static extern void GetMapfv( MapTarget target, GetMapQuery query, [Out]float[] v );
public static extern void Map2d( MapTarget target, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, double[] points );
public static extern void GetMapiv( MapTarget target, GetMapQuery query, [Out]int[] v );
internal static extern void glGetMapfv(MapTarget target, GetMapQuery query, [OutAttribute] Single* v);
public void GetMapdv(MapTarget target, GetMapTarget query, double[] v)
{
gl.glGetMapdv((int)target, (int)query, v);
}
internal static extern void glMap1d(MapTarget target, Double u1, Double u2, Int32 stride, Int32 order, Double* points);
public void GetMapiv(MapTarget target, GetMapTarget query, int[] v)
{
gl.glGetMapiv((int)target, (int)query, v);
}
internal static extern void glMap2d(MapTarget target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, Double* points);
public void Map1(MapTarget target, double u1, double u2, int stride, int order, double[] points)
{
gl.glMap1d((int)target, u1, u2, stride, order, points);
}
void NurbsCurve(IntPtr nurb, Int32 knotCount, [Out] out float knots, Int32 stride, [Out] out float control, Int32 order, MapTarget type)
{
unsafe
{
fixed (float* knots_ptr = &knots)
fixed (float* control_ptr = &control)
{
Delegates.gluNurbsCurve((IntPtr)nurb, (Int32)knotCount, (float*)knots_ptr, (Int32)stride, (float*)control_ptr, (Int32)order, (MapTarget)type);
knots = *knots_ptr;
control = *control_ptr;
}
}
}
public void Map1(MapTarget target, float u1, float u2, int stride, int order, float[] points)
{
gl.glMap1f((int)target, u1, u2, stride, order, points);
}
void NurbsSurface(IntPtr nurb, Int32 sKnotCount, ref float sKnots, Int32 tKnotCount, ref float tKnots, Int32 sStride, Int32 tStride, ref float control, Int32 sOrder, Int32 tOrder, MapTarget type)
{
unsafe
{
fixed (float* sKnots_ptr = &sKnots)
fixed (float* tKnots_ptr = &tKnots)
fixed (float* control_ptr = &control)
{
Delegates.gluNurbsSurface((IntPtr)nurb, (Int32)sKnotCount, (float*)sKnots_ptr, (Int32)tKnotCount, (float*)tKnots_ptr, (Int32)sStride, (Int32)tStride, (float*)control_ptr, (Int32)sOrder, (Int32)tOrder, (MapTarget)type);
}
}
}
public void Map2(MapTarget target, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, double[] points)
{
gl.glMap2d((int)target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}
public void Map2(MapTarget target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float[] points)
{
gl.glMap2f((int)target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}
public static unsafe void GetMapx(this OesFixedPoint thisApi, [Flow(FlowDirection.In)] MapTarget target, [Flow(FlowDirection.In)] GetMapQuery query, [Count(Computed = "query"), Flow(FlowDirection.Out)] Span <int> v)
{
// SpanOverloader
thisApi.GetMapx(target, query, out v.GetPinnableReference());
}
internal static extern void glGetMapfv(MapTarget target, GetMapQuery query, [OutAttribute] Single *v);
internal extern static unsafe void NurbsCurve(IntPtr nurb, Int32 knotCount, [Out] float* knots, Int32 stride, [Out] float* control, Int32 order, MapTarget type);
internal static extern void glMap1d(MapTarget target, Double u1, Double u2, Int32 stride, Int32 order, Double *points);
internal extern static unsafe void NurbsSurface(IntPtr nurb, Int32 sKnotCount, float* sKnots, Int32 tKnotCount, float* tKnots, Int32 sStride, Int32 tStride, float* control, Int32 sOrder, Int32 tOrder, MapTarget type);
internal static extern void glMap2d(MapTarget target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, Double *points);
void NurbsCurve(IntPtr nurb, Int32 knotCount, [Out] out float knots, Int32 stride, [Out] out float control, Int32 order, MapTarget type)
{
unsafe
{
fixed(float *knots_ptr = &knots)
fixed(float *control_ptr = &control)
{
Delegates.gluNurbsCurve((IntPtr)nurb, (Int32)knotCount, (float *)knots_ptr, (Int32)stride, (float *)control_ptr, (Int32)order, (MapTarget)type);
knots = *knots_ptr;
control = *control_ptr;
}
}
}
public static void glMap1d(MapTarget target, Double u1, Double u2, Int32 stride, Int32 order, ref Double[] points)
{
i_OpenGL1_0.glMap1d(target, u1, u2, stride, order, ref points);
}
unsafe void NurbsCurve(IntPtr nurb, Int32 knotCount, [Out] float *knots, Int32 stride, [Out] float *control, Int32 order, MapTarget type)
{
Delegates.gluNurbsCurve((IntPtr)nurb, (Int32)knotCount, (float *)knots, (Int32)stride, (float *)control, (Int32)order, (MapTarget)type);
}
public static void glMap2f(MapTarget target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, ref Single[] points)
{
i_OpenGL1_0.glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, ref points);
}
private static ITarget LoadTarget(XElement element)
{
if (element.Name == "seq")
{
var target = new MapSequence();
target.Action = LoadAction(element);
foreach (var sub in element.Elements())
{
var minCnt = 1;
var maxCnt = 1;
var handle = true;
var maximize = false;
foreach (var attr in sub.Attributes())
{
var name = attr.Name.LocalName;
if (name.StartsWith("s-"))
{
name = name.Substring(2);
if (name == "min")
{
minCnt = int.Parse(attr.Value);
}
else if (name == "max")
{
maxCnt = int.Parse(attr.Value);
}
else if (name == "handle")
{
handle = bool.Parse(attr.Value);
}
else if (name == "maximize")
{
maximize = bool.Parse(attr.Value);
}
}
}
var subTarget = LoadTarget(sub);
target.Sequence.Add(new MapSequence.SequenceToken
{
MinCount = minCnt,
MaxCount = maxCnt,
ActionHandling = handle,
Target = subTarget,
Maximize = maximize
});
}
return(target);
}
else
{
var target = new MapTarget();
target.Action = LoadAction(element);
foreach (var attr in element.Attributes())
{
var name = attr.Name.LocalName;
if (!name.Contains("-") && name != "h")
{
target.TagFilter[name] = StringFilter.Parse(attr.Value);
}
}
return(target);
}
throw new Exception("Unknown target");
}
public static void glGetMapiv(MapTarget target, GetMapQuery query, ref Int32[] v)
{
i_OpenGL1_0.glGetMapiv(target, query, ref v);
}
public static void Map1(MapTarget target, float u1, float u2, Int32 stride, Int32 order, float[] points)
{
unsafe {
fixed (float* p_points = points)
{
Debug.Assert(Delegates.pglMap1f != null, "pglMap1f not implemented");
Delegates.pglMap1f((Int32)target, u1, u2, stride, order, p_points);
CallLog("glMap1f({0}, {1}, {2}, {3}, {4}, {5})", target, u1, u2, stride, order, points);
}
}
DebugCheckErrors();
}
void NurbsSurface(IntPtr nurb, Int32 sKnotCount, ref float sKnots, Int32 tKnotCount, ref float tKnots, Int32 sStride, Int32 tStride, ref float control, Int32 sOrder, Int32 tOrder, MapTarget type)
{
unsafe
{
fixed(float *sKnots_ptr = &sKnots)
fixed(float *tKnots_ptr = &tKnots)
fixed(float *control_ptr = &control)
{
Delegates.gluNurbsSurface((IntPtr)nurb, (Int32)sKnotCount, (float *)sKnots_ptr, (Int32)tKnotCount, (float *)tKnots_ptr, (Int32)sStride, (Int32)tStride, (float *)control_ptr, (Int32)sOrder, (Int32)tOrder, (MapTarget)type);
}
}
}
public static extern void Map1f( MapTarget target, float u1, float u2, int stride, int order, float[] points );
public static void GetMap(MapTarget target, GetMapQuery query, [Out] Int32[] v)
{
unsafe {
fixed (Int32* p_v = v)
{
Debug.Assert(Delegates.pglGetMapiv != null, "pglGetMapiv not implemented");
Delegates.pglGetMapiv((Int32)target, (Int32)query, p_v);
CallLog("glGetMapiv({0}, {1}, {2})", target, query, v);
}
}
DebugCheckErrors();
}
unsafe void NurbsSurface(IntPtr nurb, Int32 sKnotCount, float *sKnots, Int32 tKnotCount, float *tKnots, Int32 sStride, Int32 tStride, float *control, Int32 sOrder, Int32 tOrder, MapTarget type)
{
Delegates.gluNurbsSurface((IntPtr)nurb, (Int32)sKnotCount, (float *)sKnots, (Int32)tKnotCount, (float *)tKnots, (Int32)sStride, (Int32)tStride, (float *)control, (Int32)sOrder, (Int32)tOrder, (MapTarget)type);
}
public static void Map2(MapTarget target, float u1, float u2, Int32 ustride, Int32 uorder, float v1, float v2, Int32 vstride, Int32 vorder, float[] points)
{
unsafe {
fixed (float* p_points = points)
{
Debug.Assert(Delegates.pglMap2f != null, "pglMap2f not implemented");
Delegates.pglMap2f((Int32)target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, p_points);
CallLog("glMap2f({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9})", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}
}
DebugCheckErrors();
}
internal static extern void glGetMapdv(MapTarget target, GetMapQuery query, [OutAttribute] Double* v);
