Corrected Tess*, Nurbs* and Quadric* definitions. Added experimental code for fast late-binding.

Source/OpenTK/OpenGL/GluHelper.cs

@@ -9,10 +9,12 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 using System.Reflection;
-using OpenTK.Platform;
+using System.Runtime.InteropServices;
 
+using OpenTK.Platform;
 using OpenTK.Math;
 using OpenTK.OpenGL.Enums;
+using System.Reflection.Emit;
 
 namespace OpenTK.OpenGL
 {
@@ -202,18 +204,6 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        public class GLUnurbs
-        {
-        }
-
-        public class GLUtesselator
-        {
-        }
-
-        public class GLUquadric
-        {
-		}
-
         #region Overloads
 
         public static void LookAt(Vector3 eye, Vector3 center, Vector3 up)
@@ -242,9 +232,9 @@ namespace OpenTK.OpenGL
             }
         }
 
-		public static void TessNormal(int tess, Vector3 normal)
+        public static void TessNormal(IntPtr tess, Vector3 normal)
         {
-			Delegates.gluTessNormal((int)tess, (double)normal.X, (double)normal.Y, (double)normal.Z);
+            Delegates.gluTessNormal(tess, (double)normal.X, (double)normal.Y, (double)normal.Z);
         }
 
         public static Int32 UnProject(Vector3 win, double[] model, double[] proj, Int32[] view, out Vector3 obj)
@@ -291,6 +281,163 @@ namespace OpenTK.OpenGL
             return ErrorString((GluErrorCode)error);
         }
 
-		#endregion
+        public static void TessWindingRuleProperty(IntPtr tess, TessWinding property)
+        {
+            Glu.TessProperty(tess, OpenTK.OpenGL.Enums.TessProperty.TessWindingRule, (double)property);
         }
+
+        #endregion
+
+    }
+
+#if false
+
+    //public delegate object
+
+    public delegate void FastVoidInvokeHandler(object target, object[] paramters);
+    public delegate object FastInvokeHandler(object target, object[] paramters);
+    public static class FastInvoker
+    {
+        /// <summary>
+        /// Use this one instead of MethodInfo.Invoke, this way it is 50 times quicker.
+        /// 
+        /// <example>
+        /// string Filter = "FirstName = 'Ton'"
+        /// MethodInfo mi = typeof(Person).GetMethod("GetAll");
+        /// snoei.net.Reflection.FastInvoker.FastInvokeHandler fi = snoei.net.Reflection.FastInvoker.GetMethodInvoker( mi );
+        ///	return fi.Invoke( Person, new object[]{Filter} );
+        /// //Calls Person.GetAll(string Filter);
+        /// </example>
+        /// </summary>
+        /// <param name="methodInfo"></param>
+        /// <returns></returns>
+        public static Delegate GetMethodInvoker(MethodInfo methodInfo)
+        {
+            DynamicMethod dynamicMethod = new DynamicMethod(string.Empty, methodInfo.ReturnType, new Type[] { typeof(object), typeof(object[]) }, methodInfo.DeclaringType.Module);
+            ILGenerator il = dynamicMethod.GetILGenerator();
+            ParameterInfo[] ps = methodInfo.GetParameters();
+            Type[] paramTypes = new Type[ps.Length];
+
+            for (int i = 0; i < paramTypes.Length; i++)
+            {
+                if (ps[i].ParameterType.IsByRef)
+                    paramTypes[i] = ps[i].ParameterType.GetElementType();
+                else
+                    paramTypes[i] = ps[i].ParameterType;
+            }
+
+            LocalBuilder[] locals = new LocalBuilder[paramTypes.Length];
+
+            for (int i = 0; i < paramTypes.Length; i++)
+                locals[i] = il.DeclareLocal(paramTypes[i], true);
+
+            for (int i = 0; i < paramTypes.Length; i++)
+            {
+                il.Emit(OpCodes.Ldarg_1);
+                EmitFastInt(il, i);
+                il.Emit(OpCodes.Ldelem_Ref);
+                EmitCastToReference(il, paramTypes[i]);
+                il.Emit(OpCodes.Stloc, locals[i]);
+            }
+
+            if (!methodInfo.IsStatic)
+                il.Emit(OpCodes.Ldarg_0);
+
+            for (int i = 0; i < paramTypes.Length; i++)
+            {
+                if (ps[i].ParameterType.IsByRef)
+                    il.Emit(OpCodes.Ldloca_S, locals[i]);
+                else
+                    il.Emit(OpCodes.Ldloc, locals[i]);
+            }
+
+            if (methodInfo.IsStatic)
+                il.EmitCall(OpCodes.Call, methodInfo, null);
+            else
+                il.EmitCall(OpCodes.Callvirt, methodInfo, null);
+
+            if (methodInfo.ReturnType == typeof(void))
+                il.Emit(OpCodes.Ldnull);
+            else
+                EmitBoxIfNeeded(il, methodInfo.ReturnType);
+
+            for (int i = 0; i < paramTypes.Length; i++)
+            {
+                if (ps[i].ParameterType.IsByRef)
+                {
+                    il.Emit(OpCodes.Ldarg_1);
+                    EmitFastInt(il, i);
+                    il.Emit(OpCodes.Ldloc, locals[i]);
+                    if (locals[i].LocalType.IsValueType)
+                        il.Emit(OpCodes.Box, locals[i].LocalType);
+                    il.Emit(OpCodes.Stelem_Ref);
+                }
+            }
+
+            il.Emit(OpCodes.Ret);
+
+            if (methodInfo.ReturnType == typeof(void))
+                return dynamicMethod.CreateDelegate(typeof(FastVoidInvokeHandler));
+            else
+                return dynamicMethod.CreateDelegate(typeof(FastInvokeHandler));
+        }
+
+        private static void EmitCastToReference(ILGenerator il, System.Type type)
+        {
+            if (type.IsValueType)
+                il.Emit(OpCodes.Unbox_Any, type);
+            else
+                il.Emit(OpCodes.Castclass, type);
+        }
+
+        private static void EmitBoxIfNeeded(ILGenerator il, System.Type type)
+        {
+            if (type.IsValueType)
+                il.Emit(OpCodes.Box, type);
+        }
+
+        private static void EmitFastInt(ILGenerator il, int value)
+        {
+            switch (value)
+            {
+                case -1:
+                    il.Emit(OpCodes.Ldc_I4_M1);
+                    return;
+                case 0:
+                    il.Emit(OpCodes.Ldc_I4_0);
+                    return;
+                case 1:
+                    il.Emit(OpCodes.Ldc_I4_1);
+                    return;
+                case 2:
+                    il.Emit(OpCodes.Ldc_I4_2);
+                    return;
+                case 3:
+                    il.Emit(OpCodes.Ldc_I4_3);
+                    return;
+                case 4:
+                    il.Emit(OpCodes.Ldc_I4_4);
+                    return;
+                case 5:
+                    il.Emit(OpCodes.Ldc_I4_5);
+                    return;
+                case 6:
+                    il.Emit(OpCodes.Ldc_I4_6);
+                    return;
+                case 7:
+                    il.Emit(OpCodes.Ldc_I4_7);
+                    return;
+                case 8:
+                    il.Emit(OpCodes.Ldc_I4_8);
+                    return;
+            }
+
+            if (value > -129 && value < 128)
+                il.Emit(OpCodes.Ldc_I4_S, (SByte)value);
+            else
+                il.Emit(OpCodes.Ldc_I4, value);
+        }
+    }
+
+#endif
 }