title: Trying to render a texture on Windows.Forms.Panels
body: <p>Using a SlimDX.Windows.RenderForm, I want to dynamically create a texture of a map of the US, copy that texture to 2 other textures, then draw unique radar data onto each texture. Then I will pass those 2 textures to each be drawn over its own Windows.Forms.Panel. This way, the user will be able to, for example, view base reflectivity and base velocity side by side in the 2 panels. Right now, I've successfully generated my map of the US onto a texture. But when I try to render it to the panels, I get black (and btw, my clear color is a soft grey, not black).</p>
  
  <p>EDIT: After some playing around, I have modified my code to take that Texture that the TextureRenderer is using, turn it to a stream, and create a new Texture under the device of the RuntimeRenderer. Now I have a soft grey square with a yellow square inside it (which is compatible with the -0.9, -0.9... 0.9, 0.9 I use for vertices). I know the new Texture is correct, but the square is still yellow.</p>
  
  <p>Here's my code:</p>
  
  <pre><code>using SlimDX;
  using SlimDX.D3DCompiler;
  using SlimDX.Direct3D11;
  using SlimDX.DXGI;
  using SlimDX.Windows;
  using System;
  using System.Windows.Forms;
  using System.Collections.Generic;
  
  using Device = SlimDX.Direct3D11.Device;
  using Buffer = SlimDX.Direct3D11.Buffer;
  using Resource = SlimDX.Direct3D11.Resource;
  using Format = SlimDX.DXGI.Format;
  using MapFlags = SlimDX.Direct3D11.MapFlags;
  
  
  
  namespace Radar
  {
  abstract public class Renderer
  {
      protected Device mDevice = null;
      protected SwapChain mSwapChain = null;
      protected RenderTargetView RenderTarget { get; set; }
  
      public Device Device { get { return mDevice; } protected set { mDevice = value; } }
      public DeviceContext Context { get { return Device.ImmediateContext; } }
      protected SwapChain SwapChain { get { return mSwapChain; } set { mSwapChain = value; } }
  
      protected int RenderTargetIndex { get; set; }
      protected VertexShader VertexShader { get; set; }
      protected PixelShader PixelShader { get; set; }
      protected Buffer VertexBuffer { get; set; }
      protected Buffer MatrixBuffer { get; set; }
      protected InputLayout Layout { get; set; }
      protected ShaderSignature InputSignature { get; set; }
      protected SamplerState SamplerState { get; set; }
  
  
  
      protected void CreateDevice(IntPtr inHandle)
      {
          SwapChainDescription chainDescription = new SwapChainDescription()
          {
              BufferCount = 2,
              Usage = Usage.RenderTargetOutput,
              OutputHandle = inHandle,
              IsWindowed = true,
              ModeDescription = new ModeDescription(0, 0, new Rational(60, 1), Format.R8G8B8A8_UNorm),
              SampleDescription = new SampleDescription(1, 0),
              Flags = SwapChainFlags.AllowModeSwitch,
              SwapEffect = SwapEffect.Discard
          };
  
          Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.Debug, chainDescription, out mDevice, out mSwapChain);
      }
  
  
  
      protected void SetupViewport(int inWidth, int inHeight)
      {
          Viewport viewport = new Viewport(0.0f, 0.0f, inWidth, inHeight);
          Context.OutputMerger.SetTargets(RenderTarget);
          Context.Rasterizer.SetViewports(viewport);
      }
  
  
  
      public void Clear()
      {
          Context.ClearRenderTargetView(RenderTarget, new Color4(0.117f, 0.117f, 0.117f));
      }
  
  
  
      public void Present()
      {
          SwapChain.Present(0, PresentFlags.None);
      }
  
  
  
      public virtual void Dispose()
      {
          SamplerState.Dispose();
          VertexBuffer.Dispose();
          Layout.Dispose();
          InputSignature.Dispose();
          VertexShader.Dispose();
          PixelShader.Dispose();
          RenderTarget.Dispose();
          SwapChain.Dispose();
          Device.Dispose();
      }
  
  
  
      public class RenderTargetParameters
      {
          public int Width { get; set; }
          public int Height { get; set; }
          public IntPtr Handle { get; set; }
  
  
          public RenderTargetParameters()
          {
              Width = 0;
              Height = 0;
              Handle = new IntPtr(0);
          }
      }
  
  
  
      // the inCount parameter is used in the TextureRenderer, but not in the code I've given
      public abstract void Render(int inCount = -1);
      public abstract void Prepare(string inShaderName = null);
  
  }
  
  
  
  // I use this to render the texture. This is working fine
  public class TextureRenderer : Renderer
  {
      .
      .
      .
  }
  
  
  
  public class RuntimeRenderer : Renderer
  {
      public TextureRenderer TextureRenderer { get; protected set; }
  
  
  
      public RuntimeRenderer(RenderTargetParameters inParms, ref TextureRenderer inTextureRenderer)
      {
          CreateDevice(inParms.Handle);
  
          TextureRenderer = inTextureRenderer;
  
          // I save to a file to make sure the texture is what it should be (and it is)
          TextureRenderer.Save();
  
          using (Resource resource = Resource.FromSwapChain&lt;Texture2D&gt;(SwapChain, 0))
              RenderTarget = new RenderTargetView(Device, resource);
  
          SetupViewport(inParms.Width, inParms.Height);
  
          using (var factory = SwapChain.GetParent&lt;Factory&gt;())
              factory.SetWindowAssociation(inParms.Handle, WindowAssociationFlags.IgnoreAltEnter);
      }
  
  
  
      public override void Prepare(string inShaderName)
      {
          DataStream data = new DataStream(12 * 4, true, true);
          data.Write(new Vector3(-0.9f, -0.9f, 0.0f));
          data.Write(new Vector3(-0.9f, 0.9f, 0.0f));
          data.Write(new Vector3(0.9f, -0.9f, 0.0f));
          data.Write(new Vector3(0.9f, 0.9f, 0.0f));
          data.Position = 0;
  
          DataStream indices = new DataStream(sizeof(int) * 4, true, true);
          indices.Write(0);
          indices.Write(1);
          indices.Write(2);
          indices.Write(3);
          indices.Position = 0;
  
          VertexBuffer = new Buffer(Device, data, (int)data.Length, ResourceUsage.Default, BindFlags.VertexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
          Buffer indexBuffer = new Buffer(Device, indices, (int)indices.Length, ResourceUsage.Default, BindFlags.IndexBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
  
          Context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(VertexBuffer, 12, 0));
          Context.InputAssembler.SetIndexBuffer(indexBuffer, Format.R32_UInt, 0);
          Context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleStrip;
  
          using (ShaderBytecode bytecode = ShaderBytecode.CompileFromFile("ShaderFX.fx", "SimpleVertexShader", "vs_5_0", ShaderFlags.Debug, EffectFlags.None))
          {
              InputSignature = ShaderSignature.GetInputSignature(bytecode);
              VertexShader = new VertexShader(Device, bytecode);
          }
  
          using (ShaderBytecode bytecode = ShaderBytecode.CompileFromFile("ShaderFX.fx", "SimplePixelShader", "ps_5_0", ShaderFlags.Debug, EffectFlags.None))
              PixelShader = new PixelShader(Device, bytecode);
  
          InputElement[] inputEl = new InputElement[2];
          inputEl[0].SemanticName = "POSITION";
          inputEl[0].SemanticIndex = 0;
          inputEl[0].Format = Format.R32G32B32_Float;
          inputEl[0].Slot = 0;
          inputEl[0].AlignedByteOffset = 0;
          inputEl[0].Classification = InputClassification.PerVertexData;
          inputEl[0].InstanceDataStepRate = 0;
  
          inputEl[1].SemanticName = "TEXCOORD";
          inputEl[1].SemanticIndex = 0;
          inputEl[1].Format = Format.R32G32_Float;
          inputEl[1].Slot = 0;
          inputEl[1].AlignedByteOffset = InputElement.AppendAligned;
          inputEl[1].Classification = InputClassification.PerVertexData;
          inputEl[1].InstanceDataStepRate = 0;
  
          Layout = new InputLayout(Device, InputSignature, inputEl);
  
          BufferDescription matrixDescription = new BufferDescription()
          {
              Usage = ResourceUsage.Dynamic,
              SizeInBytes = sizeof(float) * 16 * 3,
              BindFlags = BindFlags.ConstantBuffer,
              CpuAccessFlags = CpuAccessFlags.Write,
              OptionFlags = ResourceOptionFlags.None,
              StructureByteStride = 0
          };
  
          MatrixBuffer = new Buffer(Device, matrixDescription);
  
          ShaderResourceViewDescription resourceViewDescription = new ShaderResourceViewDescription()
          {
              Format = TextureRenderer.Texture.Description.Format,
              Dimension = ShaderResourceViewDimension.Texture2D,
              MipLevels = TextureRenderer.Texture.Description.MipLevels,
              MostDetailedMip = 0
          };
  
          ShaderResourceView resourceView = new ShaderResourceView(Device, TextureRenderer.Texture, resourceViewDescription);
  
          SamplerDescription samplerDescription = new SamplerDescription()
          {
              Filter = Filter.MinMagMipLinear,
              AddressU = TextureAddressMode.Wrap,
              AddressV = TextureAddressMode.Wrap,
              AddressW = TextureAddressMode.Wrap,
              MipLodBias = 0.0f,
              MaximumAnisotropy = 1,
              ComparisonFunction = Comparison.Always,
              BorderColor = new Color4(0, 0, 0, 0),
              MinimumLod = 0,
              MaximumLod = 99999
          };
  
          SamplerState = SamplerState.FromDescription(Device, samplerDescription);
  
          Context.InputAssembler.InputLayout = Layout;
          Context.VertexShader.Set(VertexShader);
          Context.PixelShader.Set(PixelShader);
          Context.PixelShader.SetSampler(SamplerState, 0);
  
          Vector3 position = new Vector3(0.0f, 0.0f, 10.0f);
          Vector3 target = new Vector3(0.0f, 0.0f, 0.0f);
          Matrix view = Matrix.LookAtLH(position, target, Vector3.UnitY);
          Matrix projection = Matrix.PerspectiveFovLH((float)(Math.PI / 4.0), 1.0f, 0.0f, 100.0f);
          Matrix world = Matrix.Identity;
  
          DataBox dataBox = Context.MapSubresource(MatrixBuffer, MapMode.WriteDiscard, MapFlags.None);
          dataBox.Data.Write(world);
          dataBox.Data.Write(view);
          dataBox.Data.Write(projection);
  
          Context.UnmapSubresource(MatrixBuffer, 0);
  
          Context.VertexShader.SetConstantBuffer(MatrixBuffer, 0);
          Context.PixelShader.SetShaderResource(resourceView, 0);
      }
  
  
  
      public override void Render(int inCount = -1)
      {
          Context.DrawIndexed(4, 0, 0);
      }
  }
  }
  </code></pre>
  
  <p>And here is my shader file (ShaderFX.fx):</p>
  
  <pre><code>float4 VShader(float4 position : POSITION) : SV_POSITION
  {
  return position;
  }
  
  
  
  float4 PShader_Counties(float4 position : SV_POSITION) : SV_Target
  {
  return float4(0.5f, 0.5f, 0.5f, 1.0f);
  }
  
  
  
  float4 PShader_States(float4 position : SV_POSITION) : SV_Target
  {
  return float4(0.883f, 0.883f, 0.883f, 1.0f);
  }
  
  
  
  struct VertexShaderInput
  {
  float2 pos : POSITION;
  };
  
  
  
  struct PixelShaderInput
  {
  float4 pos : SV_POSITION;
  };
  
  
  
  PixelShaderInput SimpleVertexShader(VertexShaderInput input)
  {
  PixelShaderInput vertexShaderOutput;
  
  vertexShaderOutput.pos = float4(input.pos, 0.5f, 1.0f);
  
  return vertexShaderOutput;
  }
  
  
  
  float4 SimplePixelShader(PixelShaderInput input) : SV_TARGET
  {
  return float4(1.0f, 1.0f, 0.0f, 1.0f);
  }
  </code></pre>