Xbox LIVE Indie Games
Sort Discussions: Previous Discussion Next Discussion
Page 1 of 1 (2 posts)

Parallax occlusion mapping with silhouettes in DX10?

Last post 12/29/2009 3:51 AM by Brainwurms. 1 replies.
  • 12/25/2009 3:33 PM

    Parallax occlusion mapping with silhouettes in DX10?

    Are there any good pixel shaders that give the effect of tessellation mapping or something similar in DX10, which are also easily modable to XNA?
  • 12/29/2009 3:51 AM In reply to

    Re: Parallax occlusion mapping with silhouettes in DX10?

    Okay, I've got this working on a custom mesh, but only for the leading edges:
    Here's the code - do a ctrl-F for "clip" to find my mods:
    1 //-------------------------------------------------------------------------------------- 
    2 // File: ParallaxOcclusionMapping.fx 
    3 // 
    4 // Parallax occlusion mapping implementation 
    5 //                                         
    6 // Implementation of the algorithm as described in "Dynamic Parallax Occlusion 
    7 // Mapping with Approximate Soft Shadows" paper, by N. Tatarchuk, ATI Research,  
    8 // to appear in the proceedings of ACM Symposium on Interactive 3D Graphics and Games, 2006.                                             
    9 //                                                                                
    10 // For examples of use in a real-time scene, see ATI X1K demo "ToyShop":          
    11 //    http://www.ati.com/developer/demos/rx1800.html                              
    12 // 
    13 // Copyright (c) ATI Research, Inc. All rights reserved. 
    14 //-------------------------------------------------------------------------------------- 
    15  
    16 //-------------------------------------------------------------------------------------- 
    17 // Global variables 
    18 //-------------------------------------------------------------------------------------- 
    19  
    20 texture g_baseTexture;              // Base color texture 
    21 texture g_nmhTexture;               // Normal map and height map texture pair 
    22  
    23 float4 g_materialAmbientColor;      // Material's ambient color 
    24 float4 g_materialDiffuseColor;      // Material's diffuse color 
    25 float4 g_materialSpecularColor;     // Material's specular color 
    26  
    27 float  g_fSpecularExponent;         // Material's specular exponent 
    28 bool   g_bAddSpecular;              // Toggles rendering with specular or without 
    29  
    30 // Light parameters: 
    31 float3 g_LightDir;                  // Light's direction in world space 
    32 float4 g_LightDiffuse;              // Light's diffuse color 
    33 float4 g_LightAmbient;              // Light's ambient color 
    34  
    35 float4   g_vEye;                    // Camera's location 
    36 float    g_fBaseTextureRepeat;      // The tiling factor for base and normal map textures 
    37 float    g_fHeightMapScale;         // Describes the useful range of values for the height field 
    38  
    39 // Matrices: 
    40 float4x4 g_mWorld;                  // World matrix for object 
    41 float4x4 g_mWorldViewProjection;    // World * View * Projection matrix 
    42 float4x4 g_mView;                   // View matrix  
    43  
    44 bool     g_bVisualizeLOD;           // Toggles visualization of level of detail colors 
    45 bool     g_bVisualizeMipLevel;      // Toggles visualization of mip level 
    46 bool     g_bDisplayShadows;         // Toggles display of self-occlusion based shadows 
    47  
    48 float2   g_vTextureDims;            // Specifies texture dimensions for computation of mip level at  
    49                                     // render time (width, height) 
    50  
    51 int      g_nLODThreshold;           // The mip level id for transitioning between the full computation 
    52                                     // for parallax occlusion mapping and the bump mapping computation 
    53  
    54 float    g_fShadowSoftening;        // Blurring factor for the soft shadows computation 
    55  
    56 int      g_nMinSamples;             // The minimum number of samples for sampling the height field profile 
    57 int      g_nMaxSamples;             // The maximum number of samples for sampling the height field profile 
    58  
    59  
    60  
    61 //-------------------------------------------------------------------------------------- 
    62 // Texture samplers 
    63 //-------------------------------------------------------------------------------------- 
    64 sampler tBase =  
    65 sampler_state 
    66
    67     Texture = < g_baseTexture >; 
    68     MipFilter = LINEAR; 
    69     MinFilter = LINEAR; 
    70     MagFilter = LINEAR; 
    71 }; 
    72 sampler tNormalHeightMap =  
    73 sampler_state 
    74
    75     Texture = < g_nmhTexture >; 
    76     MipFilter = LINEAR; 
    77     MinFilter = LINEAR; 
    78     MagFilter = LINEAR; 
    79 }; 
    80  
    81  
    82 //-------------------------------------------------------------------------------------- 
    83 // Vertex shader output structure 
    84 //-------------------------------------------------------------------------------------- 
    85 struct VS_OUTPUT 
    86
    87     float4 position          : POSITION; 
    88     float2 texCoord          : TEXCOORD0; 
    89     float3 vLightTS          : TEXCOORD1;   // light vector in tangent space, denormalized 
    90     float3 vViewTS           : TEXCOORD2;   // view vector in tangent space, denormalized 
    91     float2 vParallaxOffsetTS : TEXCOORD3;   // Parallax offset vector in tangent space 
    92     float3 vNormalWS         : TEXCOORD4;   // Normal vector in world space 
    93     float3 vViewWS           : TEXCOORD5;   // View vector in world space 
    94      
    95 };   
    96  
    97  
    98 //-------------------------------------------------------------------------------------- 
    99 // This shader computes standard transform and lighting 
    100 //-------------------------------------------------------------------------------------- 
    101 VS_OUTPUT RenderSceneVS( float4 inPositionOS  : POSITION,  
    102                          float2 inTexCoord    : TEXCOORD0, 
    103                          float3 vInNormalOS   : NORMAL, 
    104                          float3 vInBinormalOS : BINORMAL, 
    105                          float3 vInTangentOS  : TANGENT ) 
    106
    107     VS_OUTPUT Out; 
    108          
    109     // Transform and output input position  
    110     Out.position = mul( inPositionOS, g_mWorldViewProjection ); 
    111         
    112     // Propagate texture coordinate through: 
    113     Out.texCoord = inTexCoord * g_fBaseTextureRepeat; 
    114      
    115     // Transform the normal, tangent and binormal vectors from object space to homogeneous projection space: 
    116     float3 vNormalWS   = mul( vInNormalOS,   (float3x3) g_mWorld ); 
    117     float3 vTangentWS  = mul( vInTangentOS,  (float3x3) g_mWorld ); 
    118     float3 vBinormalWS = mul( vInBinormalOS, (float3x3) g_mWorld ); 
    119      
    120     // Propagate the world space vertex normal through:    
    121     Out.vNormalWS = vNormalWS; 
    122     vNormalWS   = normalize( vNormalWS ); 
    123     vTangentWS  = normalize( vTangentWS ); 
    124     vBinormalWS = normalize( vBinormalWS ); 
    125      
    126     // Compute position in world space: 
    127     float4 vPositionWS = mul( inPositionOS, g_mWorld ); 
    128                   
    129     // Compute and output the world view vector (unnormalized): 
    130     float3 vViewWS = g_vEye - vPositionWS; 
    131     Out.vViewWS = vViewWS; 
    132  
    133     // Compute denormalized light vector in world space: 
    134     float3 vLightWS = g_LightDir; 
    135         
    136     // Normalize the light and view vectors and transform it to the tangent space: 
    137     float3x3 mWorldToTangent = float3x3( vTangentWS, vBinormalWS, vNormalWS ); 
    138         
    139     // Propagate the view and the light vectors (in tangent space): 
    140     Out.vLightTS = mul( vLightWS, mWorldToTangent ); 
    141     Out.vViewTS  = mul( mWorldToTangent, vViewWS  ); 
    142         
    143     // Compute the ray direction for intersecting the height field profile with  
    144     // current view ray. See the above paper for derivation of this computation. 
    145           
    146     // Compute initial parallax displacement direction: 
    147     float2 vParallaxDirection = normalize(  Out.vViewTS.xy ); 
    148      
    149     // The length of this vector determines the furthest amount of displacement: 
    150     float fLength         = length( Out.vViewTS ); 
    151     float fParallaxLength = sqrt( fLength * fLength - Out.vViewTS.z * Out.vViewTS.z ) / Out.vViewTS.z;  
    152         
    153     // Compute the actual reverse parallax displacement vector: 
    154     Out.vParallaxOffsetTS = vParallaxDirection * fParallaxLength; 
    155         
    156     // Need to scale the amount of displacement to account for different height ranges 
    157     // in height maps. This is controlled by an artist-editable parameter: 
    158     Out.vParallaxOffsetTS *= g_fHeightMapScale; 
    159  
    160    return Out; 
    161 }    
    162  
    163  
    164 //-------------------------------------------------------------------------------------- 
    165 // Pixel shader output structure 
    166 //-------------------------------------------------------------------------------------- 
    167 struct PS_OUTPUT 
    168
    169     float4 RGBColor : COLOR0;  // Pixel color     
    170 }; 
    171  
    172 struct PS_INPUT 
    173
    174    float2 texCoord          : TEXCOORD0; 
    175    float3 vLightTS          : TEXCOORD1;   // light vector in tangent space, denormalized 
    176    float3 vViewTS           : TEXCOORD2;   // view vector in tangent space, denormalized 
    177    float2 vParallaxOffsetTS : TEXCOORD3;   // Parallax offset vector in tangent space 
    178    float3 vNormalWS         : TEXCOORD4;   // Normal vector in world space 
    179    float3 vViewWS           : TEXCOORD5;   // View vector in world space 
    180 }; 
    181  
    182  
    183 //-------------------------------------------------------------------------------------- 
    184 // Function:    ComputeIllumination 
    185 //  
    186 // Description: Computes phong illumination for the given pixel using its attribute  
    187 //              textures and a light vector. 
    188 //-------------------------------------------------------------------------------------- 
    189 float4 ComputeIllumination( float2 texCoord, float3 vLightTS, float3 vViewTS, float fOcclusionShadow ) 
    190
    191    // Sample the normal from the normal map for the given texture sample: 
    192    float3 vNormalTS = normalize( tex2D( tNormalHeightMap, texCoord ) * 2 - 1 ); 
    193     
    194    // Sample base map: 
    195    float4 cBaseColor = tex2D( tBase, texCoord ); 
    196     
    197    // Compute diffuse color component: 
    198    float3 vLightTSAdj = float3( vLightTS.x, -vLightTS.y, vLightTS.z ); 
    199     
    200    float4 cDiffuse = saturate( dot( vNormalTS, vLightTSAdj )) * g_materialDiffuseColor; 
    201     
    202    // Compute the specular component if desired:   
    203    float4 cSpecular = 0; 
    204    if ( g_bAddSpecular ) 
    205    { 
    206       float3 vReflectionTS = normalize( 2 * dot( vViewTS, vNormalTS ) * vNormalTS - vViewTS ); 
    207             
    208       float fRdotL = saturate( dot( vReflectionTS, vLightTSAdj )); 
    209       cSpecular = saturate( pow( fRdotL, g_fSpecularExponent )) * g_materialSpecularColor; 
    210    } 
    211     
    212    // Composite the final color: 
    213    float4 cFinalColor = (( g_materialAmbientColor + cDiffuse ) * cBaseColor + cSpecular ) * fOcclusionShadow;  
    214     
    215    return cFinalColor;   
    216 }    
    217   
    218  
    219 //-------------------------------------------------------------------------------------- 
    220 // Parallax occlusion mapping pixel shader 
    221 // 
    222 // Note: this shader contains several educational modes that would not be in the final 
    223 //       game or other complicated scene rendering. The blocks of code in various "if" 
    224 //       statements for turning off visual qualities (such as visual level of detail 
    225 //       or specular or shadows, etc), can be handled differently, and more optimally. 
    226 //       It is implemented here purely for educational purposes. 
    227 //-------------------------------------------------------------------------------------- 
    228 float4 RenderScenePS( PS_INPUT i ) : COLOR0 
    229 {  
    230  
    231    //  Normalize the interpolated vectors: 
    232    float3 vViewTS   = normalize( i.vViewTS  ); 
    233    float3 vViewWS   = normalize( i.vViewWS  ); 
    234    float3 vLightTS  = normalize( i.vLightTS ); 
    235    float3 vNormalWS = normalize( i.vNormalWS ); 
    236    float4 cResultColor = float4( 0, 0, 0, 1 ); 
    237     
    238    // Adaptive in-shader level-of-detail system implementation. Compute the  
    239    // current mip level explicitly in the pixel shader and use this information  
    240    // to transition between different levels of detail from the full effect to  
    241    // simple bump mapping. See the above paper for more discussion of the approach 
    242    // and its benefits. 
    243     
    244    // Compute the current gradients: 
    245    float2 fTexCoordsPerSize = i.texCoord * g_vTextureDims; 
    246  
    247    // Compute all 4 derivatives in x and y in a single instruction to optimize: 
    248    float2 dxSize, dySize; 
    249    float2 dx, dy; 
    250  
    251    float4( dxSize, dx ) = ddx( float4( fTexCoordsPerSize, i.texCoord ) ); 
    252    float4( dySize, dy ) = ddy( float4( fTexCoordsPerSize, i.texCoord ) ); 
    253                    
    254    float  fMipLevel;       
    255    float  fMipLevelInt;    // mip level integer portion 
    256    float  fMipLevelFrac;   // mip level fractional amount for blending in between levels 
    257  
    258    float  fMinTexCoordDelta; 
    259    float2 dTexCoords; 
    260  
    261    // Find min of change in u and v across quad: compute du and dv magnitude across quad 
    262    dTexCoords = dxSize * dxSize + dySize * dySize; 
    263     
    264    // Standard mipmapping uses max here 
    265    fMinTexCoordDelta = max( dTexCoords.x, dTexCoords.y ); 
    266  
    267    // Compute the current mip level  (* 0.5 is effectively computing a square root before ) 
    268    fMipLevel = max( 0.5 * log2( fMinTexCoordDelta ), 0 ); 
    269      
    270    // Start the current sample located at the input texture coordinate, which would correspond 
    271    // to computing a bump mapping result: 
    272    float2 texSample = i.texCoord; 
    273     
    274    // Multiplier for visualizing the level of detail (see notes for 'nLODThreshold' variable 
    275    // for how that is done visually) 
    276    float4 cLODColoring = float4( 1, 1, 3, 1 ); 
    277  
    278    float fOcclusionShadow = 1.0; 
    279  
    280    if ( fMipLevel <= (float) g_nLODThreshold ) 
    281    { 
    282       //===============================================// 
    283       // Parallax occlusion mapping offset computation // 
    284       //===============================================// 
    285  
    286       // Utilize dynamic flow control to change the number of samples per ray  
    287       // depending on the viewing angle for the surface. Oblique angles require  
    288       // smaller step sizes to achieve more accurate precision for computing displacement. 
    289       // We express the sampling rate as a linear function of the angle between  
    290       // the geometric normal and the view direction ray: 
    291       int nNumSteps = (int) lerp( g_nMaxSamples, g_nMinSamples, dot( vViewWS, vNormalWS ) ); 
    292  
    293       // Intersect the view ray with the height field profile along the direction of 
    294       // the parallax offset ray (computed in the vertex shader. Note that the code is 
    295       // designed specifically to take advantage of the dynamic flow control constructs 
    296       // in HLSL and is very sensitive to specific syntax. When converting to other examples, 
    297       // if still want to use dynamic flow control in the resulting assembly shader, 
    298       // care must be applied. 
    299       //  
    300       // In the below steps we approximate the height field profile as piecewise linear 
    301       // curve. We find the pair of endpoints between which the intersection between the  
    302       // height field profile and the view ray is found and then compute line segment 
    303       // intersection for the view ray and the line segment formed by the two endpoints. 
    304       // This intersection is the displacement offset from the original texture coordinate. 
    305       // See the above paper for more details about the process and derivation. 
    306       // 
    307  
    308       float fCurrHeight = 0.0; 
    309       float fStepSize   = 1.0 / (float) nNumSteps; 
    310       float fPrevHeight = 1.0; 
    311       float fNextHeight = 0.0; 
    312  
    313       int    nStepIndex = 0; 
    314       bool   bCondition = true
    315  
    316       float2 vTexOffsetPerStep = fStepSize * i.vParallaxOffsetTS; 
    317       float2 vTexCurrentOffset = i.texCoord; 
    318        
    319       float  fCurrentBound     = 1.0; 
    320       float  fParallaxAmount   = 0.0; 
    321  
    322       float2 pt1 = 0; 
    323       float2 pt2 = 0; 
    324         
    325       float2 texOffset2 = 0; 
    326  
    327       while ( nStepIndex < nNumSteps )  
    328       { 
    329          vTexCurrentOffset -= vTexOffsetPerStep; 
    330          // Sample height map which in this case is stored in the alpha channel of the normal map: 
    331          fCurrHeight = tex2Dgrad( tNormalHeightMap, vTexCurrentOffset, dx, dy ).a; 
    332             
    333 clip (-vTexCurrentOffset); 
    334 clip (g_fBaseTextureRepeat+vTexCurrentOffset); 
    335  
    336          fCurrentBound -= fStepSize; 
    337           
    338          if ( fCurrHeight > fCurrentBound )  
    339          {    
    340             pt1 = float2( fCurrentBound, fCurrHeight ); 
    341             pt2 = float2( fCurrentBound + fStepSize, fPrevHeight ); 
    342  
    343             texOffset2 = vTexCurrentOffset - vTexOffsetPerStep; 
    344             nStepIndex = nNumSteps + 1; 
    345             fPrevHeight = fCurrHeight; 
    346          } 
    347          else 
    348          { 
    349             nStepIndex++; 
    350             fPrevHeight = fCurrHeight; 
    351          } 
    352       }    
    353       float fDelta2 = pt2.x - pt2.y; 
    354       float fDelta1 = pt1.x - pt1.y; 
    355       float fDenominator = fDelta2 - fDelta1; 
    356        
    357       // SM 3.0 requires a check for divide by zero, since that operation will generate 
    358       // an 'Inf' number instead of 0, as previous models (conveniently) did: 
    359       if ( fDenominator == 0.0f ) 
    360       { 
    361          fParallaxAmount = 0.0f; 
    362       } 
    363       else 
    364       { 
    365          fParallaxAmount = (pt1.x * fDelta2 - pt2.x * fDelta1 ) / fDenominator; 
    366       } 
    367       float2 vParallaxOffset = i.vParallaxOffsetTS * (1 - fParallaxAmount ); 
    368       // The computed texture offset for the displaced point on the pseudo-extruded surface: 
    369       float2 texSampleBase = i.texCoord - vParallaxOffset; 
    370        
    371       texSample = texSampleBase; 
    372       // Lerp to bump mapping only if we are in between, transition section: 
    373       cLODColoring = float4( 1, 1, 1, 1 );  
    374       if ( fMipLevel > (float)(g_nLODThreshold - 1) ) 
    375       { 
    376          // Lerp based on the fractional part: 
    377          fMipLevelFrac = modf( fMipLevel, fMipLevelInt ); 
    378          if ( g_bVisualizeLOD ) 
    379          { 
    380             // For visualizing: lerping from regular POM-resulted color through blue color for transition layer: 
    381             cLODColoring = float4( 1, 1, max( 1, 2 * fMipLevelFrac ), 1 );  
    382          } 
    383  
    384          // Lerp the texture coordinate from parallax occlusion mapped coordinate to bump mapping 
    385          // smoothly based on the current mip level: 
    386          texSample = lerp( texSampleBase, i.texCoord, fMipLevelFrac ); 
    387  
    388      }   
    389        
    390      if ( g_bDisplayShadows == true ) 
    391      { 
    392         float2 vLightRayTS = vLightTS.xy * g_fHeightMapScale; 
    393         // Compute the soft blurry shadows taking into account self-occlusion for  
    394         // features of the height field: 
    395     
    396         float sh0 =  tex2Dgrad( tNormalHeightMap, texSampleBase, dx, dy ).a; 
    397         float shA = (tex2Dgrad( tNormalHeightMap, texSampleBase + vLightRayTS * 0.88, dx, dy ).a - sh0 - 0.88 ) *  1 * g_fShadowSoftening; 
    398         float sh9 = (tex2Dgrad( tNormalHeightMap, texSampleBase + vLightRayTS * 0.77, dx, dy ).a - sh0 - 0.77 ) *  2 * g_fShadowSoftening; 
    399         float sh8 = (tex2Dgrad( tNormalHeightMap, texSampleBase + vLightRayTS * 0.66, dx, dy ).a - sh0 - 0.66 ) *  4 * g_fShadowSoftening; 
    400         float sh7 = (tex2Dgrad( tNormalHeightMap, texSampleBase + vLightRayTS * 0.55, dx, dy ).a - sh0 - 0.55 ) *  6 * g_fShadowSoftening; 
    401         float sh6 = (tex2Dgrad( tNormalHeightMap, texSampleBase + vLightRayTS * 0.44, dx, dy ).a - sh0 - 0.44 ) *  8 * g_fShadowSoftening; 
    402         float sh5 = (tex2Dgrad( tNormalHeightMap, texSampleBase + vLightRayTS * 0.33, dx, dy ).a - sh0 - 0.33 ) * 10 * g_fShadowSoftening; 
    403         float sh4 = (tex2Dgrad( tNormalHeightMap, texSampleBase + vLightRayTS * 0.22, dx, dy ).a - sh0 - 0.22 ) * 12 * g_fShadowSoftening; 
    404  
    405         // Compute the actual shadow strength: 
    406         fOcclusionShadow = 1 - max( max( max( max( max( max( shA, sh9 ), sh8 ), sh7 ), sh6 ), sh5 ), sh4 ); 
    407         // The previous computation overbrightens the image, let's adjust for that: 
    408         fOcclusionShadow = fOcclusionShadow * 0.6 + 0.4;          
    409      }        
    410    }    
    411    // Compute resulting color for the pixel: 
    412    cResultColor = ComputeIllumination( texSample, vLightTS, vViewTS, fOcclusionShadow ); 
    413           
    414    if ( g_bVisualizeLOD ) 
    415    { 
    416       cResultColor *= cLODColoring; 
    417    } 
    418  
    419    // Visualize currently computed mip level, tinting the color blue if we are in  
    420    // the region outside of the threshold level: 
    421    if ( g_bVisualizeMipLevel ) 
    422    { 
    423       cResultColor = fMipLevel.xxxx;       
    424    }    
    425     
    426    // If using HDR rendering, make sure to tonemap the resuld color prior to outputting it. 
    427    // But since this example isn't doing that, we just output the computed result color here: 
    428    return cResultColor; 
    429 }    
    430  
    431  
    432 //-------------------------------------------------------------------------------------- 
    433 // Bump mapping shader 
    434 //-------------------------------------------------------------------------------------- 
    435 float4 RenderSceneBumpMapPS( PS_INPUT i ) : COLOR0 
    436 {  
    437    //  Normalize the interpolated vectors: 
    438    float3 vViewTS   = normalize( i.vViewTS  ); 
    439    float3 vLightTS  = normalize( i.vLightTS ); 
    440       
    441    float4 cResultColor = float4( 0, 0, 0, 1 ); 
    442  
    443    // Start the current sample located at the input texture coordinate, which would correspond 
    444    // to computing a bump mapping result: 
    445    float2 texSample = i.texCoord; 
    446  
    447    // Compute resulting color for the pixel: 
    448    cResultColor = ComputeIllumination( texSample, vLightTS, vViewTS, 1.0f ); 
    449                
    450    // If using HDR rendering, make sure to tonemap the resuld color prior to outputting it. 
    451    // But since this example isn't doing that, we just output the computed result color here: 
    452    return cResultColor; 
    453 }    
    454  
    455  
    456 //-------------------------------------------------------------------------------------- 
    457 // Apply parallax mapping with offset limiting technique to the current pixel 
    458 //-------------------------------------------------------------------------------------- 
    459 float4 RenderSceneParallaxMappingPS( PS_INPUT i ) : COLOR0 
    460 {  
    461    const float sfHeightBias = 0.01; 
    462     
    463    //  Normalize the interpolated vectors: 
    464    float3 vViewTS   = normalize( i.vViewTS  ); 
    465    float3 vLightTS  = normalize( i.vLightTS ); 
    466     
    467    // Sample the height map at the current texture coordinate: 
    468    float fCurrentHeight = tex2D( tNormalHeightMap, i.texCoord ).a; 
    469     
    470    // Scale and bias this height map value: 
    471    float fHeight = fCurrentHeight * g_fHeightMapScale + sfHeightBias; 
    472     
    473    // Perform offset limiting if desired: 
    474    fHeight /= vViewTS.z; 
    475     
    476    // Compute the offset vector for approximating parallax: 
    477    float2 texSample = i.texCoord + vViewTS.xy * fHeight; 
    478     
    479    float4 cResultColor = float4( 0, 0, 0, 1 ); 
    480  
    481    // Compute resulting color for the pixel: 
    482    cResultColor = ComputeIllumination( texSample, vLightTS, vViewTS, 1.0f ); 
    483                
    484    // If using HDR rendering, make sure to tonemap the resuld color prior to outputting it. 
    485    // But since this example isn't doing that, we just output the computed result color here: 
    486    return cResultColor; 
    487 }    
    488  
    489  
    490 //-------------------------------------------------------------------------------------- 
    491 // Renders scene to render target 
    492 //-------------------------------------------------------------------------------------- 
    493 technique RenderSceneWithPOM 
    494
    495     pass P0 
    496     {           
    497         VertexShader = compile vs_3_0 RenderSceneVS(); 
    498         PixelShader  = compile ps_3_0 RenderScenePS();  
    499     } 
    500
    501  
    502 technique RenderSceneWithBumpMap 
    503
    504     pass P0 
    505     {           
    506         VertexShader = compile vs_2_0 RenderSceneVS(); 
    507         PixelShader  = compile ps_2_0 RenderSceneBumpMapPS();  
    508     } 
    509
    510 technique RenderSceneWithPM 
    511
    512     pass P0 
    513     {           
    514         VertexShader = compile vs_2_0 RenderSceneVS(); 
    515         PixelShader  = compile ps_2_0 RenderSceneParallaxMappingPS();  
    516     } 
    517
    518  

Page 1 of 1 (2 posts) Previous Discussion Next Discussion