gfx/layers/d3d10/LayerManagerD3D10.fx

   1 typedef float4 rect;
   2 cbuffer PerLayer {
   3   rect vTextureCoords;
   4   rect vLayerQuad;
   5   float fLayerOpacity;
   6   float4x4 mLayerTransform;
   7 }
   8
   9 cbuffer PerOccasionalLayer {
  10   float4 vRenderTargetOffset;
  11   float4 fLayerColor;
  12 }
  13
  14 cbuffer PerLayerManager {
  15   float4x4 mProjection;
  16 }
  17
  18 BlendState Premul
  19 {
  20   AlphaToCoverageEnable = FALSE;
  21   BlendEnable[0] = TRUE;
  22   SrcBlend = One;
  23   DestBlend = Inv_Src_Alpha;
  24   BlendOp = Add;
  25   SrcBlendAlpha = One;
  26   DestBlendAlpha = Inv_Src_Alpha;
  27   BlendOpAlpha = Add;
  28   RenderTargetWriteMask[0] = 0x0F; // All
  29 };
  30
  31 BlendState NonPremul
  32 {
  33   AlphaToCoverageEnable = FALSE;
  34   BlendEnable[0] = TRUE;
  35   SrcBlend = Src_Alpha;
  36   DestBlend = Inv_Src_Alpha;
  37   BlendOp = Add;
  38   SrcBlendAlpha = One;
  39   DestBlendAlpha = Inv_Src_Alpha;
  40   BlendOpAlpha = Add;
  41   RenderTargetWriteMask[0] = 0x0F; // All
  42 };
  43
  44 BlendState ComponentAlphaBlend
  45 {
  46   AlphaToCoverageEnable = FALSE;
  47   BlendEnable[0] = TRUE;
  48   SrcBlend = One;
  49   DestBlend = Inv_Src1_Color;
  50   BlendOp = Add;
  51   SrcBlendAlpha = Zero;
  52   DestBlendAlpha = One;
  53   BlendOpAlpha = Add;
  54   RenderTargetWriteMask[0] = 0x0F; // All
  55 };
  56
  57 RasterizerState LayerRast
  58 {
  59   ScissorEnable = True;
  60   CullMode = None;
  61 };
  62
  63 Texture2D tRGB;
  64 Texture2D tY;
  65 Texture2D tCb;
  66 Texture2D tCr;
  67 Texture2D tRGBWhite;
  68
  69 SamplerState LayerTextureSamplerLinear
  70 {
  71     Filter = MIN_MAG_MIP_LINEAR;
  72     AddressU = Clamp;
  73     AddressV = Clamp;
  74 };
  75
  76 SamplerState LayerTextureSamplerPoint
  77 {
  78     Filter = MIN_MAG_MIP_POINT;
  79     AddressU = Clamp;
  80     AddressV = Clamp;
  81 };
  82
  83 struct VS_INPUT {
  84   float2 vPosition : POSITION;
  85 };
  86
  87 struct VS_OUTPUT {
  88   float4 vPosition : SV_Position;
  89   float2 vTexCoords : TEXCOORD0;
  90 };
  91
  92 struct PS_OUTPUT {
  93   float4 vSrc;
  94   float4 vAlpha;
  95 };
  96
  97 VS_OUTPUT LayerQuadVS(const VS_INPUT aVertex)
  98 {
  99   VS_OUTPUT outp;
 100   outp.vPosition.z = 0;
 101   outp.vPosition.w = 1;
 102
 103   // We use 4 component floats to uniquely describe a rectangle, by the structure
 104   // of x, y, width, height. This allows us to easily generate the 4 corners
 105   // of any rectangle from the 4 corners of the 0,0-1,1 quad that we use as the
 106   // stream source for our LayerQuad vertex shader. We do this by doing:
 107   // Xout = x + Xin * width
 108   // Yout = y + Yin * height
 109   float2 position = vLayerQuad.xy;
 110   float2 size = vLayerQuad.zw;
 111   outp.vPosition.x = position.x + aVertex.vPosition.x * size.x;
 112   outp.vPosition.y = position.y + aVertex.vPosition.y * size.y;
 113
 114   outp.vPosition = mul(mLayerTransform, outp.vPosition);
 115   outp.vPosition = outp.vPosition - vRenderTargetOffset;
 116
 117   outp.vPosition = mul(mProjection, outp.vPosition);
 118
 119   position = vTextureCoords.xy;
 120   size = vTextureCoords.zw;
 121   outp.vTexCoords.x = position.x + aVertex.vPosition.x * size.x;
 122   outp.vTexCoords.y = position.y + aVertex.vPosition.y * size.y;
 123   return outp;
 124 }
 125
 126 float4 RGBAShaderLinear(const VS_OUTPUT aVertex) : SV_Target
 127 {
 128   return tRGB.Sample(LayerTextureSamplerLinear, aVertex.vTexCoords) * fLayerOpacity;
 129 }
 130
 131 float4 RGBAShaderPoint(const VS_OUTPUT aVertex) : SV_Target
 132 {
 133   return tRGB.Sample(LayerTextureSamplerPoint, aVertex.vTexCoords) * fLayerOpacity;
 134 }
 135
 136 float4 RGBShaderLinear(const VS_OUTPUT aVertex) : SV_Target
 137 {
 138   float4 result;
 139   result = tRGB.Sample(LayerTextureSamplerLinear, aVertex.vTexCoords) * fLayerOpacity;
 140   result.a = fLayerOpacity;
 141   return result;
 142 }
 143
 144 float4 RGBShaderPoint(const VS_OUTPUT aVertex) : SV_Target
 145 {
 146   float4 result;
 147   result = tRGB.Sample(LayerTextureSamplerPoint, aVertex.vTexCoords) * fLayerOpacity;
 148   result.a = fLayerOpacity;
 149   return result;
 150 }
 151
 152 float4 YCbCrShader(const VS_OUTPUT aVertex) : SV_Target
 153 {
 154   float4 yuv;
 155   float4 color;
 156
 157   yuv.r = tCr.Sample(LayerTextureSamplerLinear, aVertex.vTexCoords).r - 0.5;
 158   yuv.g = tY.Sample(LayerTextureSamplerLinear, aVertex.vTexCoords).r - 0.0625;
 159   yuv.b = tCb.Sample(LayerTextureSamplerLinear, aVertex.vTexCoords).r - 0.5;
 160
 161   color.r = yuv.g * 1.164 + yuv.r * 1.596;
 162   color.g = yuv.g * 1.164 - 0.813 * yuv.r - 0.391 * yuv.b;
 163   color.b = yuv.g * 1.164 + yuv.b * 2.018;
 164   color.a = 1.0f;
 165
 166   return color * fLayerOpacity;
 167 }
 168
 169 PS_OUTPUT ComponentAlphaShader(const VS_OUTPUT aVertex) : SV_Target
 170 {
 171   PS_OUTPUT result;
 172
 173   result.vSrc = tRGB.Sample(LayerTextureSamplerLinear, aVertex.vTexCoords);
 174   result.vAlpha = 1.0 - tRGBWhite.Sample(LayerTextureSamplerLinear, aVertex.vTexCoords) + result.vSrc;
 175   result.vSrc *= fLayerOpacity;
 176   result.vAlpha *= fLayerOpacity;
 177   return result;
 178 }
 179
 180 float4 SolidColorShader(const VS_OUTPUT aVertex) : SV_Target
 181 {
 182   return fLayerColor;
 183 }
 184
 185 technique10 RenderRGBLayerPremul
 186 {
 187     pass P0
 188     {
 189         SetRasterizerState( LayerRast );
 190         SetBlendState( Premul, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );
 191         SetVertexShader( CompileShader( vs_4_0_level_9_3, LayerQuadVS() ) );
 192         SetGeometryShader( NULL );
 193         SetPixelShader( CompileShader( ps_4_0_level_9_3, RGBShaderLinear() ) );
 194     }
 195 }
 196
 197 technique10 RenderRGBLayerPremulPoint
 198 {
 199     pass P0
 200     {
 201         SetRasterizerState( LayerRast );
 202         SetBlendState( Premul, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );
 203         SetVertexShader( CompileShader( vs_4_0_level_9_3, LayerQuadVS() ) );
 204         SetGeometryShader( NULL );
 205         SetPixelShader( CompileShader( ps_4_0_level_9_3, RGBShaderPoint() ) );
 206     }
 207 }
 208
 209 technique10 RenderRGBALayerPremul
 210 {
 211     pass P0
 212     {
 213         SetRasterizerState( LayerRast );
 214         SetBlendState( Premul, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );
 215         SetVertexShader( CompileShader( vs_4_0_level_9_3, LayerQuadVS() ) );
 216         SetGeometryShader( NULL );
 217         SetPixelShader( CompileShader( ps_4_0_level_9_3, RGBAShaderLinear() ) );
 218     }
 219 }
 220
 221 technique10 RenderRGBALayerNonPremul
 222 {
 223     pass P0
 224     {
 225         SetRasterizerState( LayerRast );
 226         SetBlendState( NonPremul, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );
 227         SetVertexShader( CompileShader( vs_4_0_level_9_3, LayerQuadVS() ) );
 228         SetGeometryShader( NULL );
 229         SetPixelShader( CompileShader( ps_4_0_level_9_3, RGBAShaderLinear() ) );
 230     }
 231 }
 232
 233 technique10 RenderRGBALayerPremulPoint
 234 {
 235     pass P0
 236     {
 237         SetRasterizerState( LayerRast );
 238         SetBlendState( Premul, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );
 239         SetVertexShader( CompileShader( vs_4_0_level_9_3, LayerQuadVS() ) );
 240         SetGeometryShader( NULL );
 241         SetPixelShader( CompileShader( ps_4_0_level_9_3, RGBAShaderPoint() ) );
 242     }
 243 }
 244
 245 technique10 RenderRGBALayerNonPremulPoint
 246 {
 247     pass P0
 248     {
 249         SetRasterizerState( LayerRast );
 250         SetBlendState( NonPremul, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );
 251         SetVertexShader( CompileShader( vs_4_0_level_9_3, LayerQuadVS() ) );
 252         SetGeometryShader( NULL );
 253         SetPixelShader( CompileShader( ps_4_0_level_9_3, RGBAShaderPoint() ) );
 254     }
 255 }
 256
 257 technique10 RenderYCbCrLayer
 258 {
 259     pass P0
 260     {
 261         SetRasterizerState( LayerRast );
 262         SetBlendState( Premul, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );
 263         SetVertexShader( CompileShader( vs_4_0_level_9_3, LayerQuadVS() ) );
 264         SetGeometryShader( NULL );
 265         SetPixelShader( CompileShader( ps_4_0_level_9_3, YCbCrShader() ) );
 266     }
 267 }
 268
 269 technique10 RenderComponentAlphaLayer
 270 {
 271         Pass P0
 272         {
 273             SetRasterizerState( LayerRast );
 274         SetBlendState( ComponentAlphaBlend, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );
 275         SetVertexShader( CompileShader( vs_4_0_level_9_3, LayerQuadVS() ) );
 276         SetGeometryShader( NULL );
 277         SetPixelShader( CompileShader( ps_4_0_level_9_3, ComponentAlphaShader() ) );
 278         }
 279
 280 }
 281
 282 technique10 RenderSolidColorLayer
 283 {
 284     pass P0
 285     {
 286         SetRasterizerState( LayerRast );
 287         SetBlendState( Premul, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF );
 288         SetVertexShader( CompileShader( vs_4_0_level_9_3, LayerQuadVS() ) );
 289         SetGeometryShader( NULL );
 290         SetPixelShader( CompileShader( ps_4_0_level_9_3, SolidColorShader() ) );
 291     }
 292 }