public static void SetBlobCacheFuncsANDROID(IntPtr dpy, SetBlobFuncDelegate set, GetBlobFuncDelegate get)
		{
			Debug.Assert(Delegates.peglSetBlobCacheFuncsANDROID != null, "peglSetBlobCacheFuncsANDROID not implemented");
			Delegates.peglSetBlobCacheFuncsANDROID(dpy, set, get);
			LogFunction("eglSetBlobCacheFuncsANDROID(0x{0}, {1}, {2})", dpy.ToString("X8"), set, get);
			DebugCheckErrors(null);
		}
        private void CreateDevice(IntPtr windowHandle, int width, int height)
        {
            try
            {
                parameters = new PresentationParameters();

                parameters.BackBufferWidth = Math.Max(width, 1);
                parameters.BackBufferHeight = Math.Max(height, 1);
                parameters.BackBufferFormat = SurfaceFormat.Color;
                parameters.DepthStencilFormat = DepthFormat.Depth24;
                parameters.DeviceWindowHandle = windowHandle;
                parameters.PresentationInterval = PresentInterval.Immediate;
                parameters.IsFullScreen = false;

                graphicsDevice = new GraphicsDevice(
                    GraphicsAdapter.DefaultAdapter,
                    GraphicsProfile.Reach,
                    parameters);

                if (DeviceCreated != null)
                    DeviceCreated(this, EventArgs.Empty);

            }
            catch (Exception ex)
            {
                throw new ApplicationException("Failed to initialize GraphicsDeviceService. See inner exception for details.", ex);
            }
        }
Example #3
1
		internal CMSampleBuffer (IntPtr handle, bool owns)
		{
			if (!owns)
				CFObject.CFRetain (handle);

			this.handle = handle;
		}
Example #4
1
 internal static byte[] GetRawInternal(IntPtr pointer)
 {
     var ret = new byte[PyString_Size(pointer)];
     var buffer = PyString_AsString(pointer);
     Marshal.Copy(buffer, ret, 0, ret.Length);
     return ret;
 }
 public Pixels Capture(IntPtr windowHandle)
 {
     Bitmap bmp = ScreenCapture.CaptureWindow(windowHandle);
     Pixels pixels = BitmapToPixels(bmp);
     bmp.Dispose();
     return pixels;
 }
Example #6
1
 static OuyaContent()
 {
     try
     {
         {
             string strName = "tv/ouya/console/api/content/OuyaContent";
             IntPtr localRef = AndroidJNI.FindClass(strName);
             if (localRef != IntPtr.Zero)
             {
     #if VERBOSE_LOGGING
                 Debug.Log(string.Format("Found {0} class", strName));
     #endif
                 _jcOuyaContent = AndroidJNI.NewGlobalRef(localRef);
                 AndroidJNI.DeleteLocalRef(localRef);
             }
             else
             {
                 Debug.LogError(string.Format("Failed to find {0} class", strName));
             }
         }
     }
     catch (System.Exception ex)
     {
         Debug.LogError(string.Format("Exception loading JNI - {0}", ex));
     }
 }
		public unsafe BitmapDrawableResource (global::Android.Graphics.Drawables.BitmapDrawable p0, global::Com.Bumptech.Glide.Load.Engine.Bitmap_recycle.IBitmapPool p1)
			: base (IntPtr.Zero, JniHandleOwnership.DoNotTransfer)
		{
			if (Handle != IntPtr.Zero)
				return;

			try {
				JValue* __args = stackalloc JValue [2];
				__args [0] = new JValue (p0);
				__args [1] = new JValue (p1);
				if (GetType () != typeof (BitmapDrawableResource)) {
					SetHandle (
							global::Android.Runtime.JNIEnv.StartCreateInstance (GetType (), "(Landroid/graphics/drawable/BitmapDrawable;Lcom/bumptech/glide/load/engine/bitmap_recycle/BitmapPool;)V", __args),
							JniHandleOwnership.TransferLocalRef);
					global::Android.Runtime.JNIEnv.FinishCreateInstance (Handle, "(Landroid/graphics/drawable/BitmapDrawable;Lcom/bumptech/glide/load/engine/bitmap_recycle/BitmapPool;)V", __args);
					return;
				}

				if (id_ctor_Landroid_graphics_drawable_BitmapDrawable_Lcom_bumptech_glide_load_engine_bitmap_recycle_BitmapPool_ == IntPtr.Zero)
					id_ctor_Landroid_graphics_drawable_BitmapDrawable_Lcom_bumptech_glide_load_engine_bitmap_recycle_BitmapPool_ = JNIEnv.GetMethodID (class_ref, "<init>", "(Landroid/graphics/drawable/BitmapDrawable;Lcom/bumptech/glide/load/engine/bitmap_recycle/BitmapPool;)V");
				SetHandle (
						global::Android.Runtime.JNIEnv.StartCreateInstance (class_ref, id_ctor_Landroid_graphics_drawable_BitmapDrawable_Lcom_bumptech_glide_load_engine_bitmap_recycle_BitmapPool_, __args),
						JniHandleOwnership.TransferLocalRef);
				JNIEnv.FinishCreateInstance (Handle, class_ref, id_ctor_Landroid_graphics_drawable_BitmapDrawable_Lcom_bumptech_glide_load_engine_bitmap_recycle_BitmapPool_, __args);
			} finally {
			}
		}
Example #8
1
public static int set_tweenTargets(IntPtr L)
{
UIButtonColorExt self = Funcs.GetObj(L,1) as UIButtonColorExt;
if(self == null)
{
	LuaStatic.traceback(L,"nullobj call");
	LuaDLL.lua_error(L); return 1;
}
{
self.tweenTargets = new List<UnityEngine.GameObject>();
int count0= LuaDLL.lua_objlen(L,2);
for(int i0=0;i0<count0;++i0)
{
UnityEngine.GameObject itemvalue0 = default(UnityEngine.GameObject);
LuaDLL.lua_pushinteger(L,i0+1);
LuaDLL.lua_gettable(L,-2);
if (LuaDLL.lua_isnil(L, -1) == false)
{
	itemvalue0  = (UnityEngine.GameObject)Funcs.GetObj(L,-1);
}
else {
	itemvalue0  = default(UnityEngine.GameObject);
}
LuaDLL.lua_pop(L,1);
self.tweenTargets.Add(itemvalue0);
}
}
return 0;
}
		static IntPtr n_City_Ljava_lang_String_ (IntPtr jnienv, IntPtr native__this, IntPtr native_p0)
		{
			global::Com.Baidu.Mapapi.Search.Sug.SuggestionSearchOption __this = global::Java.Lang.Object.GetObject<global::Com.Baidu.Mapapi.Search.Sug.SuggestionSearchOption> (jnienv, native__this, JniHandleOwnership.DoNotTransfer);
			string p0 = JNIEnv.GetString (native_p0, JniHandleOwnership.DoNotTransfer);
			IntPtr __ret = JNIEnv.ToLocalJniHandle (__this.City (p0));
			return __ret;
		}
Example #10
1
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal unsafe static Type GetTypeHelper(Type typeStart, Type[] genericArgs, IntPtr pModifiers, int cModifiers)
        {
            Type type = typeStart;

            if (genericArgs != null)
            {
                type = type.MakeGenericType(genericArgs);
            }

            if (cModifiers > 0)
            {
                int* arModifiers = (int*)pModifiers.ToPointer();
                for(int i = 0; i < cModifiers; i++)
                {
                    if ((CorElementType)Marshal.ReadInt32((IntPtr)arModifiers, i * sizeof(int)) == CorElementType.Ptr)
                        type = type.MakePointerType();
                    
                    else if ((CorElementType)Marshal.ReadInt32((IntPtr)arModifiers, i * sizeof(int)) == CorElementType.ByRef)
                        type = type.MakeByRefType();

                    else if ((CorElementType)Marshal.ReadInt32((IntPtr)arModifiers, i * sizeof(int)) == CorElementType.SzArray)
                        type = type.MakeArrayType();

                    else
                        type = type.MakeArrayType(Marshal.ReadInt32((IntPtr)arModifiers, ++i * sizeof(int)));
                }
            }
            
            return type;
        }
Example #11
1
public static int get_tweenTargets(IntPtr L)
{
UIButtonColorExt self = Funcs.GetObj(L,1) as UIButtonColorExt;
if(self == null)
{
	LuaStatic.traceback(L,"nullobj call");
	LuaDLL.lua_error(L); return 1;
}
{
int i0 = 0;
LuaDLL.lua_newtable(L);
foreach(UnityEngine.GameObject item0 in self.tweenTargets)
{
if(item0 == null)  LuaStatic.addGameObject2Lua(L,null,""); else
{
LuaStatic.addGameObject2Lua(L,item0, "GameObject");
}
++i0;
LuaDLL.lua_pushnumber(L,i0);
LuaDLL.lua_insert(L,-2);
LuaDLL.lua_settable(L,-3);
}
}
return 1;
}
Example #12
1
        public Shader(GraphicsDevice dev, string name)
        {
            this.dev = dev;
            string code;
            using (var file = new StreamReader(FileSystem.Open("cg{0}{1}.fx".F(Path.DirectorySeparatorChar, name))))
                code = file.ReadToEnd();
            effect = Tao.Cg.Cg.cgCreateEffect(dev.Context, code, null);

            if (effect == IntPtr.Zero)
            {
                var err = Tao.Cg.Cg.cgGetErrorString(Tao.Cg.Cg.cgGetError());
                var results = Tao.Cg.Cg.cgGetLastListing(dev.Context);
                throw new InvalidOperationException(
                    "Cg compile failed ({0}):\n{1}".F(err, results));
            }

            technique = Tao.Cg.Cg.cgGetFirstTechnique(effect);
            if (technique == IntPtr.Zero)
                throw new InvalidOperationException("No techniques");
            while (Tao.Cg.Cg.cgValidateTechnique(technique) == 0)
            {
                technique = Tao.Cg.Cg.cgGetNextTechnique(technique);
                if (technique == IntPtr.Zero)
                    throw new InvalidOperationException("No valid techniques");
            }
        }
Example #13
1
 /// <summary>
 /// デバイスをクローズする
 /// </summary>
 public void Close()
 {
     if ( DeviceReady ) {
         Native.CloseHandle( hDev );
         hDev = IntPtr.Zero;
     }
 }
		public static XcbSurface FromBitmap (IntPtr connection, uint bitmap, IntPtr screen, int width, int height)
		{
			IntPtr ptr;

			ptr = CairoAPI.cairo_xcb_surface_create_for_bitmap (connection, bitmap, screen, width, height);
			return new XcbSurface (ptr, true);
		}
Example #15
1
		public object MarshalNativeToManaged (IntPtr pNativeData)
		{
			string s = UnixMarshal.PtrToString (pNativeData, UnixEncoding.Instance);
			// Console.WriteLine ("# FileNameMarshaler.MarshalNativeToManaged ({0:x})=`{1}'",
			// 		pNativeData, s);
			return s;
		}
        static internal int checkDelegate(IntPtr l,int p,out UnityEngine.Display.DisplaysUpdatedDelegate ua) {
            int op = extractFunction(l,p);
			if(LuaDLL.lua_isnil(l,p)) {
				ua=null;
				return op;
			}
            else if (LuaDLL.lua_isuserdata(l, p)==1)
            {
                ua = (UnityEngine.Display.DisplaysUpdatedDelegate)checkObj(l, p);
                return op;
            }
            LuaDelegate ld;
            checkType(l, -1, out ld);
            if(ld.d!=null)
            {
                ua = (UnityEngine.Display.DisplaysUpdatedDelegate)ld.d;
                return op;
            }
			LuaDLL.lua_pop(l,1);
			
			l = LuaState.get(l).L;
            ua = () =>
            {
                int error = pushTry(l);

				ld.pcall(0, error);
				LuaDLL.lua_settop(l, error-1);
			};
			ld.d=ua;
			return op;
		}
		public XcbSurface (IntPtr connection, uint drawable, IntPtr visual, int width, int height)
		{
			surface = CairoAPI.cairo_xcb_surface_create (connection, drawable, visual, width, height);
			lock (surfaces.SyncRoot) {
				surfaces [surface] = this;
			}
		}
        static internal int checkDelegate(IntPtr l,int p,out System.Func<System.Boolean> ua) {
            int op = extractFunction(l,p);
			if(LuaDLL.lua_isnil(l,p)) {
				ua=null;
				return op;
			}
            else if (LuaDLL.lua_isuserdata(l, p)==1)
            {
                ua = (System.Func<System.Boolean>)checkObj(l, p);
                return op;
            }
            LuaDelegate ld;
            checkType(l, -1, out ld);
            if(ld.d!=null)
            {
                ua = (System.Func<System.Boolean>)ld.d;
                return op;
            }
			LuaDLL.lua_pop(l,1);
			
			l = LuaState.get(l).L;
            ua = () =>
            {
                int error = pushTry(l);

				ld.pcall(0, error);
				bool ret;
				checkType(l,error+1,out ret);
				LuaDLL.lua_settop(l, error-1);
				return ret;
			};
			ld.d=ua;
			return op;
		}
Example #19
1
		public static extern bool DuplicateTokenEx(
			IntPtr hExistingToken,
			uint dwDesiredAccess,
			IntPtr lpTokenAttributes,
			NativeConstants.SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
			NativeConstants.TOKEN_TYPE TokenType,
			out IntPtr phNewToken);
		static IntPtr n_Location_Lcom_baidu_mapapi_model_LatLng_ (IntPtr jnienv, IntPtr native__this, IntPtr native_p0)
		{
			global::Com.Baidu.Mapapi.Search.Share.LocationShareURLOption __this = global::Java.Lang.Object.GetObject<global::Com.Baidu.Mapapi.Search.Share.LocationShareURLOption> (jnienv, native__this, JniHandleOwnership.DoNotTransfer);
			global::Com.Baidu.Mapapi.Model.LatLng p0 = global::Java.Lang.Object.GetObject<global::Com.Baidu.Mapapi.Model.LatLng> (native_p0, JniHandleOwnership.DoNotTransfer);
			IntPtr __ret = JNIEnv.ToLocalJniHandle (__this.Location (p0));
			return __ret;
		}
Example #21
1
        public Snes()
        {
            mProcess = SearchProcess("snes9x.exe");
            mProcessPtr = OpenProcess(ProcessAccessFlags.PROCESS_VM_READ, false, mProcess.Id);

            updateMemory();
        }
Example #22
1
		public static int IntPtrCopy(IntPtr source, Stream dest, int length)
		{
			var buffer = new Byte[length];
			Marshal.Copy(source, buffer, 0, length);
			dest.Write(buffer, 0, length);
			return length;
		}
        private FilterReturn FilterFunc(IntPtr xevent, Event evnt)
        {
            if (xevent == IntPtr.Zero)
                return FilterReturn.Continue;

            var e = (X11.XEvent)Marshal.PtrToStructure(xevent, typeof(X11.XEvent));

            // Dropping these events is non standard but so is embeding a Gtk into
            // a X11 Window.
            if (e.type == X11.XEventName.FocusOut ||
                e.type == X11.XEventName.LeaveNotify)
            {
                return FilterReturn.Remove;
            }

            // Ensure Mouse clicks and Button go to the right place
            if (e.type == X11.XEventName.ButtonPress ||
                e.type == X11.XEventName.KeyPress)
            {
                // TODO: possibly cancel any tooltip windows.

                this.m_parent.Focus();
                return FilterReturn.Continue;
            }

            // Everything else just process as normal
            return FilterReturn.Continue;
        }
Example #24
1
 public PtrArray(System.Type element_type, bool owned, bool elements_owned)
 {
     handle = g_ptr_array_new ();
     this.element_type = element_type;
     managed = owned;
     this.elements_owned = elements_owned;
 }
Example #25
1
 internal PtrArray(IntPtr raw, System.Type element_type, bool owned, bool elements_owned)
 {
     handle = raw;
     this.element_type = element_type;
     managed = owned;
     this.elements_owned = elements_owned;
 }
Example #26
1
		public static int State(IntPtr L)
		{
			string err;
			try
			{
				IntPtr idptr = LuaDLL.lua_touserdata(L, 1);
				System.Object obj = default(System.Object);
				Animation self = default(Animation);
				if (objs.TryGetValue(idptr.ToInt32(), out obj))
					self = objs[idptr.ToInt32()] as Animation;
				else
				{
					LuaStatic.traceback(L);
					LuaDLL.lua_error(L);
					return 1;
				}
				string statename = LuaDLL.lua_tostring(L, 2);
				AnimationState state = self[statename];
				if (state == null)
				{
					LuaDLL.lua_pushnil(L);
				}
				else
					LuaStatic.addGameObject2Lua(L, state, "AnimationState");
				return 1;
			}
			catch (Exception e)
			{
				err = e.ToString();
			}
			LuaStatic.traceback(L, err);
			LuaDLL.lua_error(L);
			return 1;
		}
Example #27
1
 public PtrArray(uint n_preallocs, System.Type element_type, bool owned, bool elements_owned)
 {
     handle = g_ptr_array_sized_new (n_preallocs);
     this.element_type = element_type;
     managed = owned;
     this.elements_owned = elements_owned;
 }
Example #28
1
 public static IShellFolder GetShellFolder(IntPtr ptrShellFolder)
 {
     System.Type shellFolderType = GetShellFolderType();
     Object obj = Marshal.GetTypedObjectForIUnknown(ptrShellFolder,shellFolderType);
     IShellFolder RetVal = (IShellFolder)obj;
     return RetVal;
 }
Example #29
1
File: Dnd.cs Project: nlhepler/mono
		internal static DataObject DragToDataObject (IntPtr dragref) {
			UInt32 items = 0;
			ArrayList flavorlist = new ArrayList ();

			CountDragItems (dragref, ref items);
			
			for (uint item_counter = 1; item_counter <= items; item_counter++) {
				IntPtr itemref = IntPtr.Zero;
				UInt32 flavors = 0;
				
				GetDragItemReferenceNumber (dragref, item_counter, ref itemref);
				CountDragItemFlavors (dragref, itemref, ref flavors);
				for (uint flavor_counter = 1; flavor_counter <= flavors; flavor_counter++) {
					FlavorHandler flavor = new FlavorHandler (dragref, itemref, flavor_counter);
					if (flavor.Supported)
						flavorlist.Add (flavor);
				}
			}

			if (flavorlist.Count > 0) {
				return ((FlavorHandler) flavorlist [0]).Convert (flavorlist);
			} 

			return new DataObject ();
		}
Example #30
1
 public static extern IntPtr create_datawriter(
     IntPtr _this,
     IntPtr a_topic,
     IntPtr qos,
     IntPtr a_listener,
     StatusKind mask
     );
 private static extern void Windows_Kinect_LongExposureInfraredFrameSource_AddRefObject(ref RootSystem.IntPtr pNative);
 private extern static void SendMessage(System.IntPtr hwnd, int wmsg, int wparam, int lparam);
Example #33
0
 public void SetFreContext(ref FREContext freContext)
 {
     Context = new FreContextSharp(freContext);
 }
Example #34
0
 public FREObject CallSharpFunction(string name, ref FREContext ctx, uint argc, FREObject[] argv)
 {
     return(FunctionsDict[name].Invoke(ctx, argc, argv));
 }
 private static extern RootSystem.IntPtr Windows_Kinect_LongExposureInfraredFrameSource_get_KinectSensor(RootSystem.IntPtr pNative);
 private static extern bool Windows_Kinect_LongExposureInfraredFrameSource_get_IsActive(RootSystem.IntPtr pNative);
 private static extern RootSystem.IntPtr Windows_Kinect_LongExposureInfraredFrameSource_get_FrameDescription(RootSystem.IntPtr pNative);
 private static extern void Windows_Kinect_LongExposureInfraredFrameSource_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
 // Constructors and Finalizers
 internal LongExposureInfraredFrameSource(RootSystem.IntPtr pNative)
 {
     _pNative = pNative;
     Windows_Kinect_LongExposureInfraredFrameSource_AddRefObject(ref _pNative);
 }
 private static extern RootSystem.IntPtr Windows_Kinect_LongExposureInfraredFrameSource_OpenReader(RootSystem.IntPtr pNative);
Example #41
0
 private static extern RootSystem.IntPtr Windows_Kinect_AudioBeamSubFrame_LockAudioBuffer(RootSystem.IntPtr pNative);
        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
        {
            List <RootSystem.EventHandler <Windows.Data.PropertyChangedEventArgs> > callbackList = null;

            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
            lock (callbackList)
            {
                var objThis = Helper.NativeObjectCache.GetObject <LongExposureInfraredFrameSource>(pNative);
                var args    = new Windows.Data.PropertyChangedEventArgs(result);
                foreach (var func in callbackList)
                {
                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
                }
            }
        }
Example #43
0
        public void MapDepthFrameToCameraSpaceUsingIntPtr(RootSystem.IntPtr depthFrameData, int depthFrameSize, RootSystem.IntPtr cameraSpacePoints, uint cameraSpacePointsSize)
        {
            if (_pNative == RootSystem.IntPtr.Zero)
            {
                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
            }

            uint length = (uint)depthFrameSize / sizeof(UInt16);

            Windows_Kinect_CoordinateMapper_MapDepthFrameToCameraSpace(_pNative, depthFrameData, length, cameraSpacePoints, cameraSpacePointsSize);
            Helper.ExceptionHelper.CheckLastError();
        }
Example #44
0
 private extern static void SendMessage(System.IntPtr hWnd, int wMsg, int wParam, int lParam);
Example #45
0
 private static extern int Windows_Kinect_CoordinateMapper_GetDepthFrameToCameraSpaceTable(RootSystem.IntPtr pNative, RootSystem.IntPtr outCollection, uint outCollectionSize);
Example #46
0
 private static extern void Windows_Kinect_AudioBeamSubFrame_CopyFrameDataToIntPtr(RootSystem.IntPtr pNative, RootSystem.IntPtr frameData, uint frameDataSize);
Example #47
0
 private static extern RootSystem.IntPtr Windows_Kinect_LongExposureInfraredFrame_LockImageBuffer(RootSystem.IntPtr pNative);
Example #48
0
 private static extern void Windows_Kinect_CoordinateMapper_MapDepthFrameToCameraSpace(
     RootSystem.IntPtr pNative,
     IntPtr depthFrameData,
     uint depthFrameDataSize,
     RootSystem.IntPtr cameraSpacePoints,
     uint cameraSpacePointsSize);
Example #49
0
 private static extern RootSystem.IntPtr Windows_Kinect_BodyIndexFrame_LockImageBuffer(RootSystem.IntPtr pNative);
Example #50
0
 private static extern RootSystem.IntPtr Windows_Kinect_CoordinateMapper_GetDepthCameraIntrinsics(RootSystem.IntPtr pNative);
Example #51
0
 private static extern RootSystem.IntPtr Windows_Kinect_ColorFrame_LockRawImageBuffer(RootSystem.IntPtr pNative);
Example #52
0
 private static extern void Windows_Kinect_LongExposureInfraredFrame_CopyFrameDataToIntPtr(RootSystem.IntPtr pNative, IntPtr frameData, uint frameDataSize);
Example #53
0
 private static extern void Windows_Kinect_ColorFrame_CopyRawFrameDataToIntPtr(RootSystem.IntPtr pNative, IntPtr frameData, uint frameDataSize);
Example #54
0
 private static extern void Windows_Kinect_BodyIndexFrame_CopyFrameDataToIntPtr(RootSystem.IntPtr pNative, IntPtr frameData, uint frameDataSize);
Example #55
0
 internal void SetIntPtr(RootSystem.IntPtr value)
 {
     _pNative = value;
 }
Example #56
0
 private static extern void Windows_Kinect_ColorFrame_CopyConvertedFrameDataToIntPtr(RootSystem.IntPtr pNative, IntPtr frameData, uint frameDataSize, Windows.Kinect.ColorImageFormat colorFormat);
Example #57
0
 private static extern int Windows_Kinect_AudioBeamFrame_get_SubFrames_Length(RootSystem.IntPtr pNative);
Example #58
0
 private static extern RootSystem.IntPtr Windows_Kinect_Body_get_Lean(RootSystem.IntPtr pNative);
Example #59
0
 private static extern int Windows_Kinect_AudioBeamFrame_get_SubFrames(RootSystem.IntPtr pNative, [RootSystem.Runtime.InteropServices.Out] RootSystem.IntPtr[] outCollection, int outCollectionSize);
Example #60
0
 private static extern void Windows_Kinect_BodyFrame_GetAndRefreshBodyData(RootSystem.IntPtr pNative, [RootSystem.Runtime.InteropServices.Out] RootSystem.IntPtr[] bodies, int bodiesSize);