Пример #1
0
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     lock (m_lock)
     {
         texture.WriteData(this.depthread, 512 * 424 * 2);
     }
 }
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     lock (m_lock)
     {
         texture.WriteData(this.colpoints, 1920 * 1080 * 8);
     }
 }
        protected override void CopyData(DX11DynamicTexture2D texture)
        {
            lock (m_lock)
            {
                for (int i = 0; i < this.colpoints.Length; i++)
                {
                    if (FRelativeLookup[0])
                    {
                        this.colorimage[i * 2] = (float)VMath.Map(colpoints[i].X - i % 1920, 0, 1920, 0, 1, TMapMode.Float);
                        this.colorimage[i * 2 + 1] = (float)VMath.Map(colpoints[i].Y - VMath.Abs(i / 1920), 0, 1080, 0, 1, TMapMode.Float);
                    }
                    else
                    {

                        this.colorimage[i * 2] = (float)VMath.Map(colpoints[i].X, 0, 1920, 0, 1, TMapMode.Clamp);
                        this.colorimage[i * 2 + 1] = (float)VMath.Map(colpoints[i].Y, 0, 1080, 0, 1, TMapMode.Clamp);
                    }
                }

                fixed (float* f = &this.colorimage[0])
                {
                    IntPtr ptr = new IntPtr(f);
                    texture.WriteData(ptr, this.width * this.height * 8);
                }
            }
        }
Пример #4
0
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     lock (m_lock)
     {
         texture.WriteData(this.depthread, 512 * 424 * 2);
     }
 }
Пример #5
0
        public void Update(IPluginIO pin, DX11RenderContext context)
        {
            if (c != null)
            {
                if (this.invalidate || !this.FTextureOutput[0].Contains(context))
                {
                    try
                    {
                        if (this.FTextureOutput[0].Contains(context))
                        {
                            this.FTextureOutput[0].Dispose(context);
                        }

                        DX11DynamicTexture2D t = new DX11DynamicTexture2D(context, this.FInW[0], this.FInH[0], SlimDX.DXGI.Format.B8G8R8A8_UNorm);


                        this.FTextureOutput[0][context] = t;
                    }
                    catch
                    {
                    }
                }

                if (this.copyframe && this.FTextureOutput[0].Contains(context))
                {
                    this.FTextureOutput[0][context].WriteData(this.rgbadata, this.size);
                }
            }
        }
Пример #6
0
        public void Update(FeralTic.DX11.DX11RenderContext context)
        {
            for (int i = 0; i < FTextureOut.SliceCount; i++)
            {
                if (!FTextureOut[i].Contains(context))
                {
                    renderer          = new BitmapRenderer();
                    renderer.TextFont = new System.Drawing.Font(FFontIn[i].Name, FFontSizeIn[i]);

                    Bitmap bmp = new Bitmap(GenerateBarcodeImage(i));

                    DX11DynamicTexture2D tex = new DX11DynamicTexture2D(context, bmp.Width, bmp.Height, SlimDX.DXGI.Format.R8G8B8A8_UNorm);

                    int pitch = tex.GetRowPitch();

                    var data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, bmp.PixelFormat);

                    if (pitch != bmp.Width * 4)
                    {
                        tex.WriteDataPitch(data.Scan0, bmp.Width * bmp.Height * 4);
                    }
                    else
                    {
                        tex.WriteData(data.Scan0, bmp.Width * bmp.Height * 4);
                    }

                    FTextureOut[i][context] = tex;
                }
            }
        }
Пример #7
0
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     lock (m_lock)
     {
         texture.WriteData(this.depthread, 1920 * 1080 * 4);
     }
 }
        public void Update(DX11RenderContext context)
        {
            if ((isImageReady && invalidate) || !this.FTextureOutput[0].Contains(context))
            {
                if (this.FTextureOutput[0].Contains(context))
                {
                    this.FTextureOutput[0].Dispose(context);
                }

                texture = new DX11DynamicTexture2D(context, width, height, SlimDX.DXGI.Format.B8G8R8A8_UNorm);
                this.FTextureOutput[0][context] = texture;
                invalidate = false;
            }

            if (browser != null && image != null && isImageReady && FEnabledIn[0])
            {
                lock (bLock)
                {
                    unsafe
                    {
                        fixed(byte *p = image)
                        {
                            texture.WriteDataPitch((IntPtr)p, width * height * 4);
                        }
                    }
                }
            }
        }
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     lock (m_lock)
     {
         texture.WriteData<byte>(this.rawdepth);
     }
 }
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     lock (m_lock)
     {
         texture.WriteData <int>(this.playerimage);
     }
 }
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     lock (m_lock)
     {
         texture.WriteData <byte>(this.rawdepth);
     }
 }
Пример #12
0
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     lock (m_lock)
     {
         texture.WriteData<int>(this.playerimage);
     }
 }
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     lock (m_lock)
     {
         texture.WriteData(this.depthread, 1920 * 1080 * 4);
     }
 }
Пример #14
0
        public void UpdateImage(DX11RenderContext context, DX11Resource <DX11DynamicTexture2D> texture, byte[] data)
        {
            if (FInvalidate || !texture.Contains(context))
            {
                var fmt = SlimDX.DXGI.Format.R8_UNorm;

                if (texture.Contains(context))
                {
                    var imgdesc = texture[context].Resource.Description;

                    if (imgdesc.Width != ValidImage.Width || imgdesc.Height != ValidImage.Height || imgdesc.Format != fmt)
                    {
                        texture.Dispose(context);
                        texture[context] = new DX11DynamicTexture2D(context, ValidImage.Width, ValidImage.Height, fmt);
                    }
                }
                else
                {
                    texture[context] = new DX11DynamicTexture2D(context, ValidImage.Width, ValidImage.Height, fmt);
#if DEBUG
                    texture[context].Resource.DebugName = "DynamicTexture";
#endif
                }
                texture[context].WriteData(data);
            }
        }
Пример #15
0
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     lock (m_lock)
     {
         texture.WriteData(this.colpoints, 1920 * 1080 * 8);
     }
 }
        public void Update(IPluginIO pin, FeralTic.DX11.DX11RenderContext context)
        {
            for (int i = 0; i < this.FTextureOut.SliceCount; i++)
            {
                if (!this.FTextureOut[i].Contains(context))
                {
                    Bitmap bmp = ComputeQRCode(i);

                    DX11DynamicTexture2D tex = new DX11DynamicTexture2D(context, bmp.Width, bmp.Height, SlimDX.DXGI.Format.R8G8B8A8_UNorm);

                    int pitch = tex.GetRowPitch();

                    var data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, bmp.PixelFormat);

                    if (pitch != bmp.Width * 4)
                    {
                        tex.WriteDataPitch(data.Scan0, bmp.Width * bmp.Height * 4);
                    }
                    else
                    {
                        tex.WriteData(data.Scan0, bmp.Width * bmp.Height * 4);
                    }

                    this.FTextureOut[i][context] = tex;
                }
            }
        }
Пример #17
0
        protected override void CopyData(DX11DynamicTexture2D texture)
        {
            lock (m_lock)
            {
                for (int i = 0; i < this.colpoints.Length; i++)
                {
                    if (FRelativeLookup[0])
                    {
                        this.colorimage[i * 2]     = (float)VMath.Map(colpoints[i].X - i % 640, 0, 640, 0, 1, TMapMode.Float);
                        this.colorimage[i * 2 + 1] = (float)VMath.Map(colpoints[i].Y - VMath.Abs(i / 640), 0, 480, 0, 1, TMapMode.Float);
                    }
                    else
                    {
                        this.colorimage[i * 2]     = (float)VMath.Map(colpoints[i].X, 0, 640, 0, 1, TMapMode.Clamp);
                        this.colorimage[i * 2 + 1] = (float)VMath.Map(colpoints[i].Y, 0, 480, 0, 1, TMapMode.Clamp);
                    }
                }

                fixed(float *f = &this.colorimage[0])
                {
                    IntPtr ptr = new IntPtr(f);

                    texture.WriteData(ptr, this.width * this.height * 8);
                }
            }
        }
Пример #18
0
        public void UpdateDistMap(DX11RenderContext context, DX11Resource <DX11DynamicTexture2D> texture, Image.CameraType side)
        {
            if (FInvalidate || !texture.Contains(context))
            {
                var fmt = SlimDX.DXGI.Format.R32G32_Float;

                if (texture.Contains(context))
                {
                    var imgdesc = texture[context].Resource.Description;

                    if (imgdesc.Width != ValidImage.DistortionWidth / 2 || imgdesc.Height != ValidImage.DistortionHeight || imgdesc.Format != fmt)
                    {
                        texture.Dispose(context);
                        texture[context] = new DX11DynamicTexture2D(context, ValidImage.DistortionWidth / 2, ValidImage.DistortionHeight, fmt);
                    }
                }
                else
                {
                    texture[context] = new DX11DynamicTexture2D(context, ValidImage.DistortionWidth / 2, ValidImage.DistortionHeight, fmt);
#if DEBUG
                    texture[context].Resource.DebugName = "DynamicTexture";
#endif
                }

                texture[context].WriteData(ValidImage.Distortion(side), 2);
            }
        }
Пример #19
0
        void CheckTextureAllocation(DX11RenderContext context)
        {
            //check if the texture we've got allocated for this context doesn't meet the current image attributes
            //this coule be on an OnImageAttributesChanged, but perhaps lazy reallocation is best
            if (FTextures.ContainsKey(context))
            {
                var tex = FTextures[context].Texture;
                if (tex.Width != this.Width || tex.Height != this.Height || tex.Format != GetFormat(FBuffer.ImageAttributes.ColorFormat))
                {
                    tex.Dispose();
                    FTextures.Remove(context);
                }
            }

            //check if we've not currently got a texture allocated for this context
            if (!FTextures.ContainsKey(context))
            {
                var tex      = new DX11DynamicTexture2D(context, Width, Height, GetFormat(FBuffer.ImageAttributes.ColorFormat));
                var resource = new Resource()
                {
                    Texture      = tex,
                    NeedsRefresh = this.FInput.Allocated,
                };
                FTextures[context]        = resource;
                this.OutputSlice[context] = tex;
            }
        }
Пример #20
0
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     fixed (float* f = &world1[0])
     {
         IntPtr ptr = new IntPtr(f);
         texture.WriteData(ptr, this.width * this.height * 4 * 4);
     }
        // texture.WriteData<float>(world1);
 }
 protected unsafe override void CopyData(DX11DynamicTexture2D texture)
 {
     lock (m_lock)
     {
         fixed(PointF *ptr = &this.data[0])
         {
             texture.WriteData(new IntPtr(ptr), this.width * this.height * 8);
         }
     }
 }
Пример #22
0
 public void Dispose()
 {
     if (this.blacktex != null)
     {
         this.blacktex.Dispose(); this.blacktex = null;
     }
     if (this.whitetex != null)
     {
         this.whitetex.Dispose(); this.whitetex = null;
     }
 }
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     lock (m_depthlock)
     {
         fixed (Vector4* cp = &this.colorread[0])
         {
             IntPtr ptr = new IntPtr(cp);
             texture.WriteData(ptr, 512 * 424 * 16);
         }
     }
 }
Пример #24
0
        protected override void CopyData(DX11DynamicTexture2D texture)
        {
            fixed(float *f = &world1[0])
            {
                IntPtr ptr = new IntPtr(f);

                texture.WriteData(ptr, this.width * this.height * 4 * 4);
            }

            // texture.WriteData<float>(world1);
        }
Пример #25
0
				public ResourcePool(DX11RenderContext context, int width, int height)
				{
					FFrontTexture = new DX11DynamicTexture2D(context, width, height, SlimDX.DXGI.Format.R8_UNorm);
					byte[] black = new byte[width * height];
					for(int i=0; i<width * height; i++)
					{
						black[i] = 0;
					}
					FFrontTexture.WriteData(black);
					FContext = context;
				}
Пример #26
0
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     lock (m_lock)
     {
         fixed (SkeletonPoint* f = &this.skelpoints[0])
         {
             IntPtr ptr = new IntPtr(f);
             texture.WriteData(ptr, this.width * this.height * 16);
         }
     }
 }
Пример #27
0
        protected override void CopyData(DX11DynamicTexture2D texture)
        {
            lock (m_depthlock)
            {
                fixed(Vector4 *cp = &this.colorread[0])
                {
                    IntPtr ptr = new IntPtr(cp);

                    texture.WriteData(ptr, 512 * 424 * 16);
                }
            }
        }
Пример #28
0
        protected override void CopyData(DX11DynamicTexture2D texture)
        {
            lock (m_lock)
            {
                fixed(SkeletonPoint *f = &this.skelpoints[0])
                {
                    IntPtr ptr = new IntPtr(f);

                    texture.WriteData(ptr, this.width * this.height * 16);
                }
            }
        }
Пример #29
0
        public void Update(DX11Resource <DX11DynamicTexture2D> textureSlice, DX11RenderContext context)
        {
            if (!this.Running || !FDataNewForTexture)
            {
                return;
            }
            FDataNewForTexture = false;

            DX11DynamicTexture2D tex;

            //create texture if necessary
            //should also check if properties (width,height) changed
            if (!textureSlice.Contains(context))
            {
                tex = new DX11DynamicTexture2D(context, FFrameWidth, FFrameHeight, SlimDX.DXGI.Format.R8_UNorm);
                textureSlice[context] = tex;
            }
            else if (textureSlice[context].Width != this.FFrameWidth || textureSlice[context].Height != this.FFrameHeight)
            {
                textureSlice[context].Dispose();
                tex = new DX11DynamicTexture2D(context, FFrameWidth, FFrameHeight, SlimDX.DXGI.Format.R8_UNorm);
                textureSlice[context] = tex;
            }
            else
            {
                tex = textureSlice[context];
            }

            FDoubleBuffer.LockFront.AcquireReaderLock(100);
            try
            {
                //write data to surface
                if (FFrameWidth == tex.GetRowPitch())
                {
                    tex.WriteData(FDoubleBuffer.Front);
                }
                else
                {
                    GCHandle pinnedArray = GCHandle.Alloc(FDoubleBuffer.Front, GCHandleType.Pinned);
                    tex.WriteDataPitch(pinnedArray.AddrOfPinnedObject(), FDoubleBuffer.Front.Length);
                    pinnedArray.Free();
                }
            }
            catch
            {
            }
            finally
            {
                FDoubleBuffer.LockFront.ReleaseReaderLock();
            }
        }
Пример #30
0
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     lock (m_lock)
     {
         if (this.FRawData[0])
         {
             texture.WriteData(this.colpoints, this.width * this.height * 8);
         }
         else
         {
             texture.WriteData(this.convertedColPoints, this.width * this.height * 8);
         }
     }
 }
Пример #31
0
            unsafe public void Update(DX11RenderContext context)
            {
                if (FOutTexture.SliceCount == 0 || buffer_ptr == IntPtr.Zero)
                {
                    return;
                }

                if (invalidate || !FOutTexture[0].Contains(context))
                {
                    // do not update buffer from here
                    lockBuffer = true;

                    SlimDX.DXGI.Format   fmt;
                    Texture2DDescription desc;

                    fmt = SlimDX.DXGI.Format.B8G8R8A8_UNorm;
                    if (FOutTexture[0].Contains(context))
                    {
                        desc = FOutTexture[0][context].Resource.Description;

                        if (desc.Width != width || desc.Height != height || desc.Format != fmt)
                        {
                            FOutTexture[0].Dispose(context);
                            FOutTexture[0][context] = new DX11DynamicTexture2D(context, width, height, fmt);
                        }
                    }
                    else
                    {
                        FOutTexture[0][context] = new DX11DynamicTexture2D(context, width, height, fmt);
                    }

                    desc = FOutTexture[0][context].Resource.Description;

                    // sometimes occur errors.
                    var t = FOutTexture[0][context];
                    t.WriteData(buffer_ptr, bufferSize);

                    invalidate = false;

                    // ready to update buffer
                    lockBuffer = false;
                }
            }
Пример #32
0
        public void Update(IPluginIO pin, DX11RenderContext context)
        {
            if (this.reset)
            {
                if (this.FTextureOutput[0].Contains(context))
                {
                    this.FTextureOutput[0].Dispose(context);
                }

                DX11DynamicTexture2D t = new DX11DynamicTexture2D(context, this.videoin.GetWidth(), this.videoin.GetHeight(), SlimDX.DXGI.Format.B8G8R8A8_UNorm);
                this.FTextureOutput[0][context] = t;
                this.reset = false;
            }

            if (this.invalidate)
            {
                this.FTextureOutput[0][context].WriteData(this.videoin.frontBuffer, this.videoin.size);
                this.invalidate = false;
            }
        }
		void CheckTextureAllocation(DX11RenderContext context)
		{
			//check if the texture we've got allocated for this context doesn't meet the current image attributes
			//this coule be on an OnImageAttributesChanged, but perhaps lazy reallocation is best
			if (FTextures.ContainsKey(context))
			{
				var tex = FTextures[context].Texture;
				if (tex.Width != this.Width || tex.Height != this.Height || tex.Format != GetFormat(FBuffer.ImageAttributes.ColorFormat))
				{
					tex.Dispose();
					FTextures.Remove(context);
				}
			}

			//check if we've not currently got a texture allocated for this context
			if (!FTextures.ContainsKey(context))
			{
				var tex = new DX11DynamicTexture2D(context, Width, Height, GetFormat(FBuffer.ImageAttributes.ColorFormat));
				var resource = new Resource()
				{
					Texture = tex,
					NeedsRefresh = this.FInput.Allocated,
				};
				FTextures[context] = resource;
				this.OutputSlice[context] = tex;
			}
		}
Пример #34
0
        public void Update(IPluginIO pin, DX11RenderContext context)
        {
            if (c != null)
            {
                if (this.invalidate || !this.FTextureOutput[0].Contains(context))
                {
                    try
                    {
                        if (this.FTextureOutput[0].Contains(context))
                        {
                            this.FTextureOutput[0].Dispose(context);
                        }

                        DX11DynamicTexture2D t = new DX11DynamicTexture2D(context, this.FInW[0], this.FInH[0], SlimDX.DXGI.Format.B8G8R8A8_UNorm);

                        this.FTextureOutput[0][context] = t;
                    }
                    catch
                    {

                    }
                }

                if (this.copyframe && this.FTextureOutput[0].Contains(context))
                {
                    this.FTextureOutput[0][context].WriteData(this.rgbadata, this.size);
                }
            }
        }
Пример #35
0
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     texture.WriteData <ColorSpacePoint>(this.points);
 }
Пример #36
0
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     texture.WriteData <byte>(this.colorimage);
 }
		public void Update(DX11Resource<DX11DynamicTexture2D> textureSlice, DX11RenderContext context)
		{
			if (!this.Running || !FDataNewForTexture)
			{
				return;
			}
			FDataNewForTexture = false;

			DX11DynamicTexture2D tex;

			//create texture if necessary
			//should also check if properties (width,height) changed
			if (!textureSlice.Contains(context))
			{
				tex = new DX11DynamicTexture2D(context, FFrameWidth, FFrameHeight, SlimDX.DXGI.Format.R8_UNorm);
				textureSlice[context] = tex;
			}
			else if (textureSlice[context].Width != this.FFrameWidth || textureSlice[context].Height != this.FFrameHeight)
			{
				textureSlice[context].Dispose();
				tex = new DX11DynamicTexture2D(context, FFrameWidth, FFrameHeight, SlimDX.DXGI.Format.R8_UNorm);
				textureSlice[context] = tex;
			}
			else
			{
				tex = textureSlice[context];
			}

			FDoubleBuffer.LockFront.AcquireReaderLock(100);
			try
			{
				//write data to surface
				if (FFrameWidth == tex.GetRowPitch())
				{
					tex.WriteData(FDoubleBuffer.Front);
				}
				else
				{
					GCHandle pinnedArray = GCHandle.Alloc(FDoubleBuffer.Front, GCHandleType.Pinned);
					tex.WriteDataPitch(pinnedArray.AddrOfPinnedObject(), FDoubleBuffer.Front.Length);
					pinnedArray.Free();
				}
			}
			catch
			{
			}
			finally
			{
				FDoubleBuffer.LockFront.ReleaseReaderLock();
			}
		}
Пример #38
0
			unsafe void ThreadedFunction()
			{
				Random random = new Random();
				Thread.Sleep((int)(random.NextDouble() * 1000.0));

				while(FRunningThread)
				{
					try
					{
						if (FNeedsRelist)
						{
							try
							{
								var filenames = Directory.GetFiles(FPath, FMask);
								lock (FMemoryPoolLock)
								{
									FMemoryPool.Clear();
									foreach (var filename in filenames)
									{
										var image = new Image();
										image.Filename = filename;
										FMemoryPool.Add(image);
									}
								}
							}
							catch (Exception e)
							{
								FLogger.Log(e);
							}
							FNeedsRelist = false;
						}

						lock (FMemoryPoolLock)
						{
							int imageIndex = 0;
							foreach (var image in FMemoryPool)
							{
								try
								{
									if (!image.LoadedCPU)
									{
										var bitmap = new Bitmap(image.Filename);
										image.Data = new byte[FWidth * FHeight];
										var bitmapData = bitmap.LockBits(new Rectangle(0, 0, FWidth, FHeight), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
										Exception e3 = null;
										try
										{
											byte* input = (byte*)bitmapData.Scan0;
											fixed (byte* outputFixed = &image.Data[0])
											{
												byte* output = outputFixed;
												for (int i = 0; i < FWidth * FHeight; i++)
												{
													input++; //a

													int pixelData = 0;
													pixelData += *input++;
													pixelData += *input++;
													pixelData += *input++;

													*output++ = (byte)(pixelData / 3);
												}
											}

											image.LoadedCPU = true;
										}
										catch (Exception e2)
										{
											e3 = e2;
										}
										finally
										{
											bitmap.UnlockBits(bitmapData);
										}
										if (e3 != null)
										{
											throw (e3);
										}
										//we've done enough work for this cycle
										break;
									}

									lock (FTexturePoolLock)
									{
										foreach (var resourcePool in FTexturePool)
										{
											lock(FLockCreation)// make sure all threads don't go crazy at the same time
											{
												var context = resourcePool.Key;
												var texturePool = resourcePool.Value.FTextures;
												if (texturePool.Count <= imageIndex)
												{
													var texture = new DX11DynamicTexture2D(context, FWidth, FHeight, SlimDX.DXGI.Format.R8_UNorm);

													GCHandle pinnedArray = GCHandle.Alloc(image.Data, GCHandleType.Pinned);
													IntPtr pointer = pinnedArray.AddrOfPinnedObject();
													texture.WriteDataPitch(pointer, image.Data.Length, FWidth);
													pinnedArray.Free();

													texturePool.Add(texture);
												}
											}
											//we've done enough work for this cycle
											break;
										}
									}
								}
								catch (Exception e)
								{
									FLogger.Log(e);
								}
								imageIndex++;
							}
						}
					}
					catch(Exception e)
					{

					}
					Thread.Sleep(10);
				}
			}
Пример #39
0
        public void Update(DX11RenderContext context)
        {
            Stopwatch w = Stopwatch.StartNew();

            int cnt = 0;

            foreach (VlcPlayer vlc in this.players)
            {
                if (vlc != null)
                {
                    if (vlc.IsValid && vlc.Width > 0 && vlc.Height > 0)
                    {
                        DX11DynamicTexture2D t;
                        if (!this.FTextureOut[cnt].Contains(context))
                        {
                            t = new DX11DynamicTexture2D(context, vlc.Width, vlc.Height, SlimDX.DXGI.Format.B8G8R8A8_UNorm);
                            #if DEBUG
                            t.Resource.DebugName = "Vlc";
                            #endif
                            this.FTextureOut[cnt][context] = t;
                        }
                        else
                        {
                            t = this.FTextureOut[cnt][context];
                            if (t.Width != vlc.Width || t.Height != vlc.Height)
                            {
                                this.FTextureOut[cnt].Dispose(context);
                                DX11DynamicTexture2D t2 = new DX11DynamicTexture2D(context, vlc.Width, vlc.Height, SlimDX.DXGI.Format.B8G8R8A8_UNorm);
                                #if DEBUG
                                t2.Resource.DebugName = "Vlc";
                                #endif
                                this.FTextureOut[cnt][context] = t2;
                                t = t2;
                            }
                        }

                        if (vlc.Play)
                        {
                            IntPtr ptr = vlc.frontBuffer;

                            if (ptr != IntPtr.Zero)
                            {
                                if (vlc.Width * 4 == t.GetRowPitch())
                                {
                                    t.WriteData(ptr, vlc.Width * vlc.Height * 4);
                                }
                                else
                                {
                                    t.WriteDataPitch(ptr, vlc.Width * vlc.Height * 4);
                                }
                            }
                        }
                    }
                    else
                    {
                        this.FTextureOut[cnt].Dispose(context);
                    }
                }
                cnt++;
            }

            w.Stop();
            this.FPinOutCopyTime.SetValue(0, w.ElapsedMilliseconds);
        }
Пример #40
0
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     texture.WriteDataStride(this.rawdepth);
 }
Пример #41
0
        public void Update(IPluginIO pin, DX11RenderContext context)
        {
            Stopwatch w = Stopwatch.StartNew();

            int cnt = 0;
            foreach (VlcPlayer vlc in this.players)
            {

                if (vlc != null)
                {
                    if (vlc.IsValid)
                    {
                        DX11DynamicTexture2D t;
                        if (!this.FTextureOut[cnt].Contains(context))
                        {
                            t = new DX11DynamicTexture2D(context, vlc.Width, vlc.Height, SlimDX.DXGI.Format.B8G8R8A8_UNorm);
                            #if DEBUG
                            t.Resource.DebugName = "Vlc";
                            #endif
                            this.FTextureOut[cnt][context] = t;
                        }
                        else
                        {
                            t = this.FTextureOut[cnt][context];
                            if (t.Width != vlc.Width || t.Height != vlc.Height)
                            {
                                this.FTextureOut[cnt].Dispose(context);
                                DX11DynamicTexture2D t2 = new DX11DynamicTexture2D(context, vlc.Width, vlc.Height, SlimDX.DXGI.Format.B8G8R8A8_UNorm);
                                #if DEBUG
                                t2.Resource.DebugName = "Vlc";
                                #endif
                                this.FTextureOut[cnt][context] = t2;
                                t = t2;
                            }
                        }

                        if (vlc.Play)
                        {
                            IntPtr ptr = vlc.frontBuffer;

                            if (vlc.Width * 4 == t.GetRowPitch())
                            {
                                t.WriteData(ptr, vlc.Width * vlc.Height * 4);
                            }
                            else
                            {
                                t.WriteDataPitch(ptr, vlc.Width * vlc.Height * 4);
                            }
                        }
                    }
                    else
                    {
                        this.FTextureOut[cnt].Dispose(context);
                    }
                }
                cnt++;
            }

            w.Stop();
            this.FPinOutCopyTime.SetValue(0, w.ElapsedMilliseconds);
        }
Пример #42
0
 protected abstract void CopyData(DX11DynamicTexture2D texture);
Пример #43
0
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     texture.WriteDataStride(this.rawdepth);
 }
Пример #44
0
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     texture.WriteData<ColorSpacePoint>(this.points);
 }
Пример #45
0
 protected override void CopyData(DX11DynamicTexture2D texture)
 {
     texture.WriteData<byte>(this.colorimage);
 }
Пример #46
0
 public void Dispose()
 {
     if (this.blacktex != null) { this.blacktex.Dispose(); this.blacktex = null; }
     if (this.whitetex != null) { this.whitetex.Dispose(); this.whitetex = null; }
 }
Пример #47
0
        public void Update(IPluginIO pin, FeralTic.DX11.DX11RenderContext context)
        {
            for (int i = 0; i < this.FTextureOut.SliceCount; i++)
            {
                if (!this.FTextureOut[i].Contains(context))
                {
                    Bitmap bmp = ComputeQRCode(i);

                    DX11DynamicTexture2D tex = new DX11DynamicTexture2D(context, bmp.Width, bmp.Height, SlimDX.DXGI.Format.R8G8B8A8_UNorm);

                    int pitch = tex.GetRowPitch();

                    var data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, bmp.PixelFormat);

                    if (pitch != bmp.Width * 4)
                    {
                        tex.WriteDataPitch(data.Scan0, bmp.Width * bmp.Height * 4);
                    }
                    else
                    {
                        tex.WriteData(data.Scan0, bmp.Width * bmp.Height * 4);
                    }

                    this.FTextureOut[i][context] = tex;

                }
            }
        }
Пример #48
0
        public void Update(IPluginIO pin, DX11RenderContext context)
        {
            if (this.reset)
            {
                if (this.FTextureOutput[0].Contains(context))
                {
                    this.FTextureOutput[0].Dispose(context);
                }

                DX11DynamicTexture2D t = new DX11DynamicTexture2D(context, this.videoin.GetWidth(), this.videoin.GetHeight(), SlimDX.DXGI.Format.B8G8R8A8_UNorm);
                this.FTextureOutput[0][context] = t;
                this.reset = false;
            }

            if (this.invalidate)
            {
                this.FTextureOutput[0][context].WriteData(this.videoin.frontBuffer, this.videoin.size);
                this.invalidate = false;
            }
        }
Пример #49
0
 protected abstract void CopyData(DX11DynamicTexture2D texture);
Пример #50
0
            // ======================================================
            // dx11
            // ======================================================
            unsafe public void Update(DX11RenderContext context)
            {
                if (FOutTexture.SliceCount == 0 || glControl.Size.Width == 0 || glControl.Size.Height == 0)
                {
                    return;
                }

                if (this.invalidate || !FOutTexture[0].Contains(context))
                {
                    Format format = Format.R8G8B8A8_UNorm;
                    Texture2DDescription desc;

                    //this.width = glControl.Size.Width;
                    //this.height = glControl.Size.Height;
                    //pixelBuffer = new byte[this.width * this.height * channels];
                    //flippedBuffer = new byte[pixelBuffer.Length];

                    if (FOutTexture[0].Contains(context))
                    {
                        desc = FOutTexture[0][context].Resource.Description;
                        if (desc.Width != this.width || desc.Height != this.height || desc.Format != format)
                        {
                            FOutTexture[0].Dispose(context);
                            FOutTexture[0][context] = new DX11DynamicTexture2D(context, this.width, this.height, format);
                        }
                    }
                    else
                    {
                        FOutTexture[0][context] = new DX11DynamicTexture2D(context, this.width, this.height, format);
                    }

                    desc = FOutTexture[0][context].Resource.Description;

                    // GL.getPixels results is flipped vertically, so fix it
                    int rowIndex, colIndex, srcIndex, dstIndex;
                    for (int i = 0; i < this.width * this.height; i++)
                    {
                        rowIndex = (this.height - 1) - (i / this.width);
                        colIndex = i % this.width;
                        srcIndex = ((rowIndex * this.width) + colIndex) * channels;
                        dstIndex = i * channels;

                        flippedBuffer[dstIndex]     = pixelBuffer[srcIndex];
                        flippedBuffer[dstIndex + 1] = pixelBuffer[srcIndex + 1];
                        flippedBuffer[dstIndex + 2] = pixelBuffer[srcIndex + 2];
                        flippedBuffer[dstIndex + 3] = pixelBuffer[srcIndex + 3];
                    }

                    //int stride = channels;
                    var t = FOutTexture[0][context];
                    //t.WriteData(flippedBuffer);
                    //t.WriteData(pixelBuffer);

                    fixed(byte *b_ptr = &flippedBuffer[0])
                    {
                        IntPtr ptr = new IntPtr(b_ptr);

                        if (t.GetRowPitch() == desc.Width * channels)
                        {
                            t.WriteData(ptr, desc.Width * desc.Height * channels);
                        }
                        else
                        {
                            t.WriteDataPitch(ptr, desc.Width * desc.Height * channels, channels);
                        }
                    }

                    this.invalidate = false;
                }
            }