home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 275 / DPCS0111DVD.ISO / Toolkit / Audio-Visual / VirtualDub / Source / VirtualDub-1.9.10-src.7z / src / Riza / source / displaydx9_ps1.fxh < prev    next >
Encoding:
Text File  |  2009-09-14  |  14.9 KB  |  556 lines
  1. //    VirtualDub - Video processing and capture application
  2. //    A/V interface library
  3. //    Copyright (C) 1998-2008 Avery Lee
  4. //
  5. //    This program is free software; you can redistribute it and/or modify
  6. //    it under the terms of the GNU General Public License as published by
  7. //    the Free Software Foundation; either version 2 of the License, or
  8. //    (at your option) any later version.
  9. //
  10. //    This program is distributed in the hope that it will be useful,
  11. //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. //    GNU General Public License for more details.
  14. //
  15. //    You should have received a copy of the GNU General Public License
  16. //    along with this program; if not, write to the Free Software
  17. //    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  
  19. #ifndef DISPLAYDX9_PS1_FXH
  20. #define DISPLAYDX9_PS1_FXH
  21.  
  22. ////////////////////////////////////////////////////////////////////////////////////////////////////
  23. //
  24. //    Pixel shader 1.1 bicubic path - 4 texture stages, 2 passes (NVIDIA GeForce3/4)
  25. //
  26. ////////////////////////////////////////////////////////////////////////////////////////////////////
  27.  
  28. static const float offset = 1.0f / 128.0f;
  29.  
  30. struct VertexOutputBicubic1_1 {
  31.     float4    pos        : POSITION;
  32.     float2    uvfilt    : TEXCOORD0;
  33.     float2    uvsrc0    : TEXCOORD1;
  34.     float2    uvsrc1    : TEXCOORD2;
  35.     float2    uvsrc2    : TEXCOORD3;
  36. };
  37.  
  38. VertexOutputBicubic1_1 VertexShaderBicubic1_1A(VertexInput IN) {
  39.     VertexOutputBicubic1_1 OUT;
  40.     
  41.     OUT.pos = IN.pos;
  42.     OUT.uvfilt.x = IN.uv2.x * vd_vpsize.x * vd_interphtexsize.w;
  43.     OUT.uvfilt.y = 0;
  44.     OUT.uvsrc0 = IN.uv + float2(-1.0f + offset, vd_fieldinfo.y)*vd_texsize.wz;
  45.     OUT.uvsrc1 = IN.uv + float2( 0.0f + offset, vd_fieldinfo.y)*vd_texsize.wz;
  46.     OUT.uvsrc2 = IN.uv + float2(+1.0f + offset, vd_fieldinfo.y)*vd_texsize.wz;
  47.     return OUT;
  48. }
  49.  
  50. VertexOutputBicubic1_1 VertexShaderBicubic1_1B(VertexInput IN) {
  51.     VertexOutputBicubic1_1 OUT;
  52.     
  53.     OUT.pos = IN.pos;
  54.     OUT.uvfilt.x = IN.uv2.y * vd_vpsize.y * vd_interpvtexsize.w;
  55.     OUT.uvfilt.y = 0;
  56.     
  57.     float2 uv = IN.uv2 * float2(vd_vpsize.x, vd_srcsize.y) * vd_tempsize.wz;
  58.     OUT.uvsrc0 = uv + float2(0, -1.0f + offset)*vd_tempsize.wz;
  59.     OUT.uvsrc1 = uv + float2(0,  0.0f + offset)*vd_tempsize.wz;
  60.     OUT.uvsrc2 = uv + float2(0, +1.0f + offset)*vd_tempsize.wz;
  61.     return OUT;
  62. }
  63.  
  64. pixelshader PixelShaderBicubic1_1 = asm {
  65.     ps_1_1
  66.     tex t0                ;displacement texture
  67.     texbeml t1, t0        ;p0/p1 weighted
  68.     texbeml t2, t0        ;p1/p2 weighted
  69.     texbeml t3, t0        ;p2/p3 weighted
  70.     add_d2 r0, t1, t3
  71.     add_x2 r0, t2, -r0
  72. };
  73.  
  74. technique bicubic1_1 {
  75.     pass horiz <
  76.         string vd_target="temp";
  77.         string vd_viewport="out, src";
  78.         string vd_bumpenvscale="vd_texsize";
  79.     > {
  80.         VertexShader = compile vs_1_1 VertexShaderBicubic1_1A();
  81.         PixelShader = <PixelShaderBicubic1_1>;
  82.         
  83.         Texture[0] = <vd_interphtexture>;
  84.         AddressU[0] = Clamp;
  85.         AddressV[0] = Clamp;
  86.         MipFilter[0] = None;
  87.         MinFilter[0] = Point;
  88.         MagFilter[0] = Point;
  89.  
  90.         Texture[1] = <vd_srctexture>;
  91.         AddressU[1] = Clamp;
  92.         AddressV[1] = Clamp;
  93.         MipFilter[1] = None;
  94.         MinFilter[1] = Linear;
  95.         MagFilter[1] = Linear;
  96.         BumpEnvMat00[1] = 0.0f;
  97.         BumpEnvMat01[1] = 0.0f;
  98.         BumpEnvMat10[1] = 0.0f;
  99.         BumpEnvMat11[1] = 0.0f;
  100.         BumpEnvLScale[1] = <0.25f*0.75f>;
  101.         BumpEnvLOffset[1] = 0.0f;
  102.         
  103.         Texture[2] = <vd_srctexture>;
  104.         AddressU[2] = Clamp;
  105.         AddressV[2] = Clamp;
  106.         MipFilter[2] = None;
  107.         MinFilter[2] = Linear;
  108.         MagFilter[2] = Linear;
  109.         BumpEnvMat00[2] = 0.0f;
  110.         BumpEnvMat01[2] = 0.0f;
  111.         BumpEnvMat10[2] = 0.25f;
  112.         BumpEnvMat11[2] = 0.0f;
  113.         BumpEnvLScale[2] = <0.25f*0.75f>;
  114.         BumpEnvLOffset[2] = 0.5f;
  115.  
  116.         Texture[3] = <vd_srctexture>;
  117.         AddressU[3] = Clamp;
  118.         AddressV[3] = Clamp;
  119.         MipFilter[3] = None;
  120.         MinFilter[3] = Linear;
  121.         MagFilter[3] = Linear;
  122.         BumpEnvMat00[3] = 0.0f;
  123.         BumpEnvMat01[3] = 0.0f;
  124.         BumpEnvMat10[3] = 0.0f;
  125.         BumpEnvMat11[3] = 0.0f;
  126.         BumpEnvLScale[3] = <0.25f*0.75f>;
  127.         BumpEnvLOffset[3] = 0.0f;
  128.     }
  129.     
  130.     pass vert <
  131.         string vd_target="";
  132.         string vd_viewport="out,out";
  133.         string vd_bumpenvscale="vd_tempsize";
  134.     > {
  135.         VertexShader = compile vs_1_1 VertexShaderBicubic1_1B();
  136.         PixelShader = <PixelShaderBicubic1_1>;
  137.         Texture[0] = <vd_interpvtexture>;
  138.         Texture[1] = <vd_temptexture>;
  139.         Texture[2] = <vd_temptexture>;
  140.         BumpEnvMat10[2] = 0.0f;
  141.         BumpEnvMat11[2] = 0.25f;
  142.         Texture[3] = <vd_temptexture>;
  143.     }
  144. }
  145.  
  146. ////////////////////////////////////////////////////////////////////////////////////////////////////
  147. //
  148. //    UYVY/YUY2 to RGB -- pixel shader 1.1
  149. //
  150. ////////////////////////////////////////////////////////////////////////////////////////////////////
  151.  
  152. void VS_UYVY_to_RGB_1_1(
  153.     float4 pos : POSITION,
  154.     float2 uv : TEXCOORD0,
  155.     float2 uv2 : TEXCOORD1,
  156.     out float4 oPos : POSITION,
  157.     out float2 oT0 : TEXCOORD0,
  158.     out float2 oT1 : TEXCOORD1,
  159.     out float2 oT2 : TEXCOORD2)
  160. {
  161.     oPos = pos;
  162.     oT0 = uv;
  163.     oT1 = oT0 + vd_texsize.wz * float2(0.25, 0);
  164.     oT2.x = vd_srcsize.x * uv2.x / 16.0f;
  165.     oT2.y = 0;
  166. }
  167.  
  168. technique uyvy_to_rgb_1_1 {
  169.     pass < string vd_viewport = "unclipped,unclipped"; > {
  170.         VertexShader = compile vs_1_1 VS_UYVY_to_RGB_1_1();
  171.  
  172.         PixelShader = asm {
  173.             ps_1_1
  174.             def c0, 0.4065, 0, 0.1955, 0.582        // -Cr->G/2, 0, -Cb->G/2, Y_coeff/2
  175.             def c1, 0.399, 0, 0.5045, -0.0627451    // Cr->R/4, 0, Cb->B/4, -Y_bias
  176.             def c2, 0, 1, 0, 0
  177.  
  178.             tex t0                            // Y
  179.             tex t1                            // C
  180.             tex t2                            // select
  181.             
  182.             dp3 r0, t0, c2                    // select Y1 from green
  183.             
  184.             dp3 r1.rgb, t1_bias, c0            // compute chroma green / 2
  185.             + lrp r0.a, t2.a, t0.a, r0.a    // select Y1/Y2 based on even/odd
  186.             
  187.             mul r1.rgb, r1, c2                // restrict chroma green to green channel
  188.             
  189.             mad r1.rgb, t1_bx2, c1, -r1        // compute chroma red/blue / 2 and merge chroma green
  190.             + add r0.a, r0.a, c1.a            // add luma bias (-16/255)
  191.             
  192.             mad_x2 r0.rgb, r0.a, c0.a, r1    // scale luma and merge chroma
  193.             + mov r0.a, c2.a
  194.         };
  195.         
  196.         Texture[0] = <vd_srctexture>;
  197.         AddressU[0] = Clamp;
  198.         AddressV[0] = Clamp;
  199.         MinFilter[0] = Point;
  200.         MagFilter[0] = Point;
  201.  
  202.         Texture[1] = <vd_srctexture>;
  203.         AddressU[1] = Clamp;
  204.         AddressV[1] = Clamp;
  205.         MinFilter[1] = Linear;
  206.         MagFilter[1] = Linear;
  207.         
  208.         Texture[2] = <vd_hevenoddtexture>;
  209.         AddressU[2] = Wrap;
  210.         AddressV[2] = Clamp;
  211.         MinFilter[2] = Point;
  212.         MagFilter[2] = Point;
  213.     }
  214. }
  215.  
  216. technique hdyc_to_rgb_1_1 {
  217.     pass < string vd_viewport = "unclipped,unclipped"; > {
  218.         VertexShader = compile vs_1_1 VS_UYVY_to_RGB_1_1();
  219.  
  220.         PixelShader = asm {
  221.             ps_1_1
  222.             def c0, 0.2665, 0, 0.1065, 0.582        // -Cr->G/2, 0, -Cb->G/2, Y_coeff/2
  223.             def c1, 0.44825, 0, 0.528, -0.0627451    // Cr->R/4, 0, Cb->B/4, -Y_bias
  224.             def c2, 0, 1, 0, 0
  225.  
  226.             tex t0                            // Y
  227.             tex t1                            // C
  228.             tex t2                            // select
  229.             
  230.             dp3 r0, t0, c2                    // select Y1 from green
  231.             
  232.             dp3 r1.rgb, t1_bias, c0            // compute chroma green / 2
  233.             + lrp r0.a, t2.a, t0.a, r0.a    // select Y1/Y2 based on even/odd
  234.             
  235.             mul r1.rgb, r1, c2                // restrict chroma green to green channel
  236.             
  237.             mad r1.rgb, t1_bx2, c1, -r1        // compute chroma red/blue / 2 and merge chroma green
  238.             + add r0.a, r0.a, c1.a            // add luma bias (-16/255)
  239.             
  240.             mad_x2 r0.rgb, r0.a, c0.a, r1    // scale luma and merge chroma
  241.             + mov r0.a, c2.a
  242.         };
  243.         
  244.         Texture[0] = <vd_srctexture>;
  245.         AddressU[0] = Clamp;
  246.         AddressV[0] = Clamp;
  247.         MinFilter[0] = Point;
  248.         MagFilter[0] = Point;
  249.  
  250.         Texture[1] = <vd_srctexture>;
  251.         AddressU[1] = Clamp;
  252.         AddressV[1] = Clamp;
  253.         MinFilter[1] = Linear;
  254.         MagFilter[1] = Linear;
  255.         
  256.         Texture[2] = <vd_hevenoddtexture>;
  257.         AddressU[2] = Wrap;
  258.         AddressV[2] = Clamp;
  259.         MinFilter[2] = Point;
  260.         MagFilter[2] = Point;
  261.     }
  262. }
  263.  
  264. technique yuy2_to_rgb_1_1 {
  265.     pass < string vd_viewport = "unclipped,unclipped"; > {
  266.         VertexShader = compile vs_1_1 VS_UYVY_to_RGB_1_1();
  267.  
  268.         PixelShader = asm {
  269.             ps_1_1
  270.             def c0, 0, 0.1955, 0, 0.582        // 0, -Cb->G/2, 0, Y_coeff/2
  271.             def c1, 0, 0.5045, 0, -0.0627451// 0, Cb->B/4, 0, -Y_bias
  272.             def c2, 0, 1, 0, 0.4065            // [green], -Cr->G/2
  273.             def c3, 1, 0, 0, 0.798            // [red], Cr->R/2
  274.  
  275.             tex t0                            // Y
  276.             tex t1                            // C
  277.             tex t2                            // select
  278.             
  279.             dp3 r1.rgb, t1_bias, c0            // compute chroma green / 2 (Cb half)
  280.             
  281.             dp3 t2.rgb, t0, c3                // extract Y1 (red)
  282.             + mad r1.a, t1_bias, c2.a, r1.b    // compute chroma green / 2
  283.                         
  284.             dp3 r0.rgb, t1_bx2, c1            // compute Cb (green) -> chroma blue
  285.             + mul r0.a, t1_bias, c3.a        // compute Cr (alpha) -> chroma red
  286.  
  287.             lrp r1.rgb, c2, -r1.a, r0        // merge chroma green and chroma blue
  288.             + lrp t0.a, t2.a, t2.b, t0.b    // select Y from Y1 (red) and Y2 (blue)
  289.             
  290.             lrp r1.rgb, c3, r0.a, r1        // merge chroma red
  291.             + add t0.a, t0.a, c1.a            // add luma bias (-16/255)
  292.             
  293.             mad_x2 r0.rgb, t0.a, c0.a, r1    // scale luma and merge chroma
  294.             + mov r0.a, c2.a
  295.         };
  296.         
  297.         Texture[0] = <vd_srctexture>;
  298.         AddressU[0] = Clamp;
  299.         AddressV[0] = Clamp;
  300.         MinFilter[0] = Point;
  301.         MagFilter[0] = Point;
  302.  
  303.         Texture[1] = <vd_srctexture>;
  304.         AddressU[1] = Clamp;
  305.         AddressV[1] = Clamp;
  306.         MinFilter[1] = Linear;
  307.         MagFilter[1] = Linear;
  308.         
  309.         Texture[2] = <vd_hevenoddtexture>;
  310.         AddressU[2] = Wrap;
  311.         AddressV[2] = Clamp;
  312.         MinFilter[2] = Point;
  313.         MagFilter[2] = Point;
  314.     }
  315. }
  316.  
  317. ////////////////////////////////////////////////////////////////////////////////////////////////////
  318. //
  319. //    UYVY/YUY2 to RGB -- pixel shader 1.1
  320. //
  321. ////////////////////////////////////////////////////////////////////////////////////////////////////
  322.  
  323. void VS_NV12_to_RGB_1_1(
  324.     float4 pos : POSITION,
  325.     float2 uv : TEXCOORD0,
  326.     float2 uv2 : TEXCOORD1,
  327.     out float4 oPos : POSITION,
  328.     out float2 oT0 : TEXCOORD0,
  329.     out float2 oT1 : TEXCOORD1)
  330. {
  331.     oPos = pos;
  332.     oT0 = uv;
  333.     oT1 = oT0 + vd_texsize.wz * float2(0.25, 0);
  334. }
  335.  
  336. technique nv12_to_rgb_1_1 {
  337.     pass < string vd_viewport = "unclipped,unclipped"; > {
  338.         VertexShader = compile vs_1_1 VS_NV12_to_RGB_1_1();
  339.  
  340.         PixelShader = asm {
  341.             ps_1_1
  342.             def c0, 0.582192, 0.582192, 0.582192, -0.0627451        // Y/2, Y_bias
  343.             def c1, 0, -0.0979406, 0.504308, 0        // Cb/4
  344.             def c2, 0.798013, -0.406484, 0, 0        // Cr/2
  345.  
  346.             tex t0                            // Y
  347.             tex t1                            // C
  348.  
  349.             mul_x2 r0.rgb, t1_bias, c1
  350.             + add t0.a, t0.b, c0.a
  351.             mad r0.rgb, t1_bias.a, c2, r0
  352.             mad_x2 r0.rgb, t0.a, c0, r0
  353.             + mov r0.a, c1.a
  354.         };
  355.         
  356.         Texture[0] = <vd_srctexture>;
  357.         AddressU[0] = Clamp;
  358.         AddressV[0] = Clamp;
  359.         MinFilter[0] = Point;
  360.         MagFilter[0] = Point;
  361.  
  362.         Texture[1] = <vd_src2atexture>;
  363.         AddressU[1] = Clamp;
  364.         AddressV[1] = Clamp;
  365.         MinFilter[1] = Linear;
  366.         MagFilter[1] = Linear;
  367.     }
  368. }
  369.  
  370. ////////////////////////////////////////////////////////////////////////////////////////////////////
  371. //
  372. //    YCbCr to RGB -- pixel shader 1.1
  373. //
  374. ////////////////////////////////////////////////////////////////////////////////////////////////////
  375.  
  376. void VS_YCbCr_to_RGB_1_1(
  377.     float4 pos : POSITION,
  378.     float2 uv : TEXCOORD0,
  379.     float2 uv2 : TEXCOORD1,
  380.     out float4 oPos : POSITION,
  381.     out float2 oT0 : TEXCOORD0,
  382.     out float2 oT1 : TEXCOORD1,
  383.     out float2 oT2 : TEXCOORD2,
  384.     uniform float2 scale,
  385.     uniform float2 offset)
  386. {
  387.     oPos = pos;
  388.     oT0 = uv;
  389.     oT1 = (uv2 * scale * vd_srcsize.xy + offset) * vd_tex2size.wz;
  390.     oT2 = (uv2 * scale * vd_srcsize.xy + offset) * vd_tex2size.wz;
  391. }
  392.  
  393. pixelshader PS_YCbCr_to_RGB_1_1 = asm {
  394.     ps_1_1
  395.  
  396.     def c0, 0, -0.09775, 0.5045, -0.0365176
  397.     def c1, 0.798, -0.4065, 0, 0.582
  398.  
  399.     tex t0                            // Y
  400.     tex t1                            // Cb
  401.     tex t2                            // Cr
  402.     
  403.     mad r0, t1_bx2, c0, c0.a
  404.     mad r0, t2_bias, c1, r0
  405.     mad_x2 r0, t0, c1.a, r0
  406. };
  407.  
  408. technique yvu9_to_rgb_1_1 {
  409.     pass < string vd_viewport = "unclipped,unclipped"; > {
  410.         VertexShader = compile vs_1_1 VS_YCbCr_to_RGB_1_1(float2(0.25, 0.25), float2(0, 0));
  411.         PixelShader = <PS_YCbCr_to_RGB_1_1>;
  412.         
  413.         Texture[0] = <vd_srctexture>;
  414.         AddressU[0] = Clamp;
  415.         AddressV[0] = Clamp;
  416.         MinFilter[0] = Point;
  417.         MagFilter[0] = Point;
  418.  
  419.         Texture[1] = <vd_src2atexture>;
  420.         AddressU[1] = Clamp;
  421.         AddressV[1] = Clamp;
  422.         MinFilter[1] = Linear;
  423.         MagFilter[1] = Linear;
  424.         
  425.         Texture[2] = <vd_src2btexture>;
  426.         AddressU[2] = Clamp;
  427.         AddressV[2] = Clamp;
  428.         MinFilter[2] = Linear;
  429.         MagFilter[2] = Linear;
  430.     }
  431. }
  432.  
  433. technique yv12_to_rgb_1_1 {
  434.     pass < string vd_viewport = "unclipped,unclipped"; > {
  435.         VertexShader = compile vs_1_1 VS_YCbCr_to_RGB_1_1(float2(0.5, 0.5), float2(-0.25, 0));
  436.         PixelShader = <PS_YCbCr_to_RGB_1_1>;
  437.         
  438.         Texture[0] = <vd_srctexture>;
  439.         AddressU[0] = Clamp;
  440.         AddressV[0] = Clamp;
  441.         MinFilter[0] = Point;
  442.         MagFilter[0] = Point;
  443.  
  444.         Texture[1] = <vd_src2atexture>;
  445.         AddressU[1] = Clamp;
  446.         AddressV[1] = Clamp;
  447.         MinFilter[1] = Linear;
  448.         MagFilter[1] = Linear;
  449.         
  450.         Texture[2] = <vd_src2btexture>;
  451.         AddressU[2] = Clamp;
  452.         AddressV[2] = Clamp;
  453.         MinFilter[2] = Linear;
  454.         MagFilter[2] = Linear;
  455.     }
  456. }
  457.  
  458. technique yv16_to_rgb_1_1 {
  459.     pass < string vd_viewport = "unclipped,unclipped"; > {
  460.         VertexShader = compile vs_1_1 VS_YCbCr_to_RGB_1_1(float2(0.5, 1), float2(-0.25, 0));
  461.         PixelShader = <PS_YCbCr_to_RGB_1_1>;
  462.         
  463.         Texture[0] = <vd_srctexture>;
  464.         AddressU[0] = Clamp;
  465.         AddressV[0] = Clamp;
  466.         MinFilter[0] = Point;
  467.         MagFilter[0] = Point;
  468.  
  469.         Texture[1] = <vd_src2atexture>;
  470.         AddressU[1] = Clamp;
  471.         AddressV[1] = Clamp;
  472.         MinFilter[1] = Linear;
  473.         MagFilter[1] = Linear;
  474.         
  475.         Texture[2] = <vd_src2btexture>;
  476.         AddressU[2] = Clamp;
  477.         AddressV[2] = Clamp;
  478.         MinFilter[2] = Linear;
  479.         MagFilter[2] = Linear;
  480.     }
  481. }
  482.  
  483. technique yv24_to_rgb_1_1 {
  484.     pass < string vd_viewport = "unclipped,unclipped"; > {
  485.         VertexShader = compile vs_1_1 VS_YCbCr_to_RGB_1_1(float2(1, 1), float2(0, 0));
  486.         PixelShader = <PS_YCbCr_to_RGB_1_1>;
  487.         
  488.         Texture[0] = <vd_srctexture>;
  489.         AddressU[0] = Clamp;
  490.         AddressV[0] = Clamp;
  491.         MinFilter[0] = Point;
  492.         MagFilter[0] = Point;
  493.  
  494.         Texture[1] = <vd_src2atexture>;
  495.         AddressU[1] = Clamp;
  496.         AddressV[1] = Clamp;
  497.         MinFilter[1] = Linear;
  498.         MagFilter[1] = Linear;
  499.         
  500.         Texture[2] = <vd_src2btexture>;
  501.         AddressU[2] = Clamp;
  502.         AddressV[2] = Clamp;
  503.         MinFilter[2] = Linear;
  504.         MagFilter[2] = Linear;
  505.     }
  506. }
  507.  
  508. ////////////////////////////////////////////////////////////////////////////////////////////////////
  509. //
  510. //    Pal8 to RGB -- pixel shader 1.1
  511. //
  512. ////////////////////////////////////////////////////////////////////////////////////////////////////
  513.  
  514. void VS_Pal8_to_RGB_1_1(
  515.     float4 pos : POSITION,
  516.     float2 uv : TEXCOORD0,
  517.     float2 uv2 : TEXCOORD1,
  518.     out float4 oPos : POSITION,
  519.     out float2 oT0 : TEXCOORD0,
  520.     out float3 oT1 : TEXCOORD1,
  521.     out float3 oT2 : TEXCOORD2)
  522. {
  523.     oPos = pos;
  524.     oT0 = uv;
  525.     oT1 = float3(0, 255.75f / 256.0f, 0);
  526.     oT2 = float3(0, 0, 0);
  527. }
  528.     
  529.  
  530. technique pal8_to_rgb_1_1 {
  531.     pass < string vd_viewport = "unclipped,unclipped"; > {
  532.         VertexShader = compile vs_1_1 VS_Pal8_to_RGB_1_1();
  533.         PixelShader = asm {
  534.             ps_1_1
  535.             tex t0
  536.             texm3x2pad t1, t0
  537.             texm3x2tex t2, t0
  538.             mov r0, t2
  539.         };
  540.         
  541.         Texture[0] = <vd_srctexture>;
  542.         AddressU[0] = Clamp;
  543.         AddressV[0] = Clamp;
  544.         MinFilter[0] = Point;
  545.         MagFilter[0] = Point;
  546.         
  547.         Texture[2] = <vd_srcpaltexture>;
  548.         AddressU[2] = Clamp;
  549.         AddressV[2] = Clamp;
  550.         MinFilter[2] = Point;
  551.         MagFilter[2] = Point;
  552.     }
  553. }
  554.  
  555. #endif
  556.