]> git.cworth.org Git - apitrace/blob - thirdparty/directxtex/DirectXTex/DirectXTexNormalMaps.cpp
directxtex: Fix include filename case.
[apitrace] / thirdparty / directxtex / DirectXTex / DirectXTexNormalMaps.cpp
1 //-------------------------------------------------------------------------------------
2 // DirectXTexNormalMaps.cpp
3 //  
4 // DirectX Texture Library - Normal map operations
5 //
6 // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
7 // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
8 // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
9 // PARTICULAR PURPOSE.
10 //
11 // Copyright (c) Microsoft Corporation. All rights reserved.
12 //
13 // http://go.microsoft.com/fwlink/?LinkId=248926
14 //-------------------------------------------------------------------------------------
15
16 #include "DirectXTexP.h"
17
18 namespace DirectX
19 {
20
21 #pragma prefast(suppress : 25000, "FXMVECTOR is 16 bytes")
22 static inline float _EvaluateColor( _In_ FXMVECTOR val, _In_ DWORD flags )
23 {
24     XMFLOAT4A f;
25
26     static XMVECTORF32 lScale = { 0.2125f, 0.7154f, 0.0721f, 1.f };
27
28     static_assert( CNMAP_CHANNEL_RED == 0x1, "CNMAP_CHANNEL_ flag values don't match mask" );
29     switch( flags & 0xf )
30     {
31     case 0:
32     case CNMAP_CHANNEL_RED:     return XMVectorGetX( val );
33     case CNMAP_CHANNEL_GREEN:   return XMVectorGetY( val );
34     case CNMAP_CHANNEL_BLUE:    return XMVectorGetZ( val );
35     case CNMAP_CHANNEL_ALPHA:   return XMVectorGetW( val );
36
37     case CNMAP_CHANNEL_LUMINANCE:
38         {
39             XMVECTOR v = XMVectorMultiply( val, lScale );
40             XMStoreFloat4A( &f, v );
41             return f.x + f.y + f.z;
42         }
43         break;
44
45     default:
46         assert(false);
47         return 0.f;
48     }
49 }
50
51 static void _EvaluateRow( _In_count_(width) const XMVECTOR* pSource, _Out_cap_(width+2) float* pDest,
52                           _In_ size_t width, _In_ DWORD flags )
53 {
54     assert( pSource && pDest );
55     assert( width > 0 );
56
57     for( size_t x = 0; x < width; ++x )
58     {
59         pDest[x+1] = _EvaluateColor( pSource[x], flags );
60     }
61
62     if ( flags & CNMAP_MIRROR_U )
63     {
64         // Mirror in U
65         pDest[0] = _EvaluateColor( pSource[0], flags );
66         pDest[width+1] = _EvaluateColor( pSource[width-1], flags );
67     }
68     else
69     {
70         // Wrap in U
71         pDest[0] = _EvaluateColor( pSource[width-1], flags );
72         pDest[width+1] = _EvaluateColor( pSource[0], flags );
73     }
74 }
75
76 static HRESULT _ComputeNMap( _In_ const Image& srcImage, _In_ DWORD flags, _In_ float amplitude,
77                              _In_ DXGI_FORMAT format, _In_ const Image& normalMap )
78 {
79     if ( !srcImage.pixels || !normalMap.pixels )
80         return E_INVALIDARG;
81
82     assert( !IsCompressed(format) && !IsTypeless( format ) );
83
84     const DWORD convFlags = _GetConvertFlags( format );
85     if ( !convFlags )
86         return E_FAIL;
87
88     if ( !( convFlags & (CONVF_UNORM | CONVF_SNORM | CONVF_FLOAT) ) )
89         HRESULT_FROM_WIN32( ERROR_NOT_SUPPORTED );
90
91     const size_t width = srcImage.width;
92     const size_t height = srcImage.height;
93     if ( width != normalMap.width || height != normalMap.height )
94         return E_FAIL;
95
96     // Allocate temporary space (4 scanlines and 3 evaluated rows)
97     ScopedAlignedArrayXMVECTOR scanline( reinterpret_cast<XMVECTOR*>( _aligned_malloc( (sizeof(XMVECTOR)*width*4), 16 ) ) );
98     if ( !scanline )
99         return E_OUTOFMEMORY;
100
101     ScopedAlignedArrayFloat buffer( reinterpret_cast<float*>( _aligned_malloc( ( ( sizeof(float) * ( width + 2 ) ) * 3 ), 16 ) ) );
102     if ( !buffer )
103         return E_OUTOFMEMORY;
104
105     uint8_t* pDest = normalMap.pixels;
106     if ( !pDest )
107         return E_POINTER;
108
109     XMVECTOR* row0 = scanline.get();
110     XMVECTOR* row1 = row0 + width;
111     XMVECTOR* row2 = row1 + width;
112     XMVECTOR* target = row2 + width;
113
114     float* val0 = buffer.get();
115     float* val1 = val0 + width + 2;
116     float* val2 = val1 + width + 2;
117
118     const size_t rowPitch = srcImage.rowPitch;
119     const uint8_t* pSrc = srcImage.pixels;
120
121     // Read first scanline row into 'row1'
122     if ( !_LoadScanline( row1, width, pSrc, rowPitch, srcImage.format ) )
123         return E_FAIL;
124
125     // Setup 'row0'
126     if ( flags & CNMAP_MIRROR_V )
127     {
128         // Mirror first row
129         memcpy_s( row0, rowPitch, row1, rowPitch );
130     }
131     else
132     {
133         // Read last row (Wrap V)
134         if ( !_LoadScanline( row0, width, pSrc + (rowPitch * (height-1)), rowPitch, srcImage.format ) )
135             return E_FAIL;
136     }
137
138     // Evaluate the initial rows
139     _EvaluateRow( row0, val0, width, flags );
140     _EvaluateRow( row1, val1, width, flags );
141
142     pSrc += rowPitch;
143
144     for( size_t y = 0; y < height; ++y )
145     {
146         // Load next scanline of source image
147         if ( y < (height-1) )
148         {
149             if ( !_LoadScanline( row2, width, pSrc, rowPitch, srcImage.format ) )
150                 return E_FAIL;
151         }
152         else
153         {
154             if ( flags & CNMAP_MIRROR_V )
155             {
156                 // Use last row of source image
157                 if ( !_LoadScanline( row2, width, srcImage.pixels + (rowPitch * (height-1)), rowPitch, srcImage.format ) )
158                     return E_FAIL;
159             }
160             else
161             {
162                 // Use first row of source image (Wrap V)
163                 if ( !_LoadScanline( row2, width, srcImage.pixels, rowPitch, srcImage.format ) )
164                     return E_FAIL;
165             }
166         }
167
168         // Evaluate row
169         _EvaluateRow( row2, val2, width, flags );
170
171         // Generate target scanline
172         XMVECTOR *dptr = target;
173         for( size_t x = 0; x < width; ++x )
174         {
175             // Compute normal via central differencing
176             float totDelta = ( val0[x] - val0[x+2] ) + ( val1[x] - val1[x+2] ) + ( val2[x] - val2[x+2] );
177             float deltaZX = totDelta * amplitude / 6.f;
178
179             totDelta = ( val0[x] - val2[x] ) + ( val0[x+1] - val2[x+1] ) + ( val0[x+2] - val2[x+2] );
180             float deltaZY = totDelta * amplitude / 6.f;
181
182             XMVECTOR vx = XMVectorSetZ( g_XMNegIdentityR0, deltaZX );   // (-1.0f, 0.0f, deltaZX)
183             XMVECTOR vy = XMVectorSetZ( g_XMNegIdentityR1, deltaZY );   // (0.0f, -1.0f, deltaZY)
184
185             XMVECTOR normal = XMVector3Normalize( XMVector3Cross( vx, vy ) );
186
187             // Compute alpha (1.0 or an occlusion term)
188             float alpha = 1.f;
189
190             if ( flags & CNMAP_COMPUTE_OCCLUSION )
191             {
192                 float delta = 0.f;
193                 float c = val1[x+1];
194
195                 float t = val0[x] - c;  if ( t > 0.f ) delta += t;
196                 t = val0[x+1]   - c;    if ( t > 0.f ) delta += t;
197                 t = val0[x+2]   - c;    if ( t > 0.f ) delta += t;
198                 t = val1[x]     - c;    if ( t > 0.f ) delta += t;
199                 // Skip current pixel
200                 t = val1[x+2]   - c;    if ( t > 0.f ) delta += t;
201                 t = val2[x]     - c;    if ( t > 0.f ) delta += t;
202                 t = val2[x+1]   - c;    if ( t > 0.f ) delta += t;
203                 t = val2[x+2]   - c;    if ( t > 0.f ) delta += t;
204
205                 // Average delta (divide by 8, scale by amplitude factor)
206                 delta *= 0.125f * amplitude;
207                 if ( delta > 0.f )
208                 {
209                     // If < 0, then no occlusion
210                     float r = sqrtf( 1.f + delta*delta );
211                     alpha = (r - delta) / r;
212                 }
213             }
214
215             // Encode based on target format
216             if ( convFlags & CONVF_UNORM )
217             {
218                 // 0.5f*normal + 0.5f -or- invert sign case: -0.5f*normal + 0.5f
219                 XMVECTOR n1 = XMVectorMultiplyAdd( (flags & CNMAP_INVERT_SIGN) ? g_XMNegativeOneHalf : g_XMOneHalf, normal, g_XMOneHalf ); 
220                 *dptr++ = XMVectorSetW( n1, alpha );
221             }
222             else if ( flags & CNMAP_INVERT_SIGN )
223             {
224                 *dptr++ = XMVectorSetW( XMVectorNegate( normal ), alpha );
225             }
226             else
227             {
228                 *dptr++ = XMVectorSetW( normal, alpha );
229             }
230         }
231
232         if ( !_StoreScanline( pDest, normalMap.rowPitch, format, target, width ) )
233             return E_FAIL;
234
235         // Cycle buffers
236         float* temp = val0;
237         val0 = val1;
238         val1 = val2;
239         val2 = temp;
240
241         pSrc += rowPitch;
242         pDest += normalMap.rowPitch;
243     }
244
245     return S_OK;
246 }
247
248
249 //=====================================================================================
250 // Entry points
251 //=====================================================================================
252         
253 //-------------------------------------------------------------------------------------
254 // Generates a normal map from a height-map
255 //-------------------------------------------------------------------------------------
256 HRESULT ComputeNormalMap( const Image& srcImage, DWORD flags, float amplitude,
257                           DXGI_FORMAT format, ScratchImage& normalMap )
258 {
259     if ( !srcImage.pixels || !IsValid(format) || IsCompressed( format ) || IsTypeless( format ) )
260         return E_INVALIDARG;
261
262     static_assert( CNMAP_CHANNEL_RED == 0x1, "CNMAP_CHANNEL_ flag values don't match mask" );
263     switch( flags & 0xf )
264     {
265     case 0:
266     case CNMAP_CHANNEL_RED:
267     case CNMAP_CHANNEL_GREEN:
268     case CNMAP_CHANNEL_BLUE:
269     case CNMAP_CHANNEL_ALPHA:
270     case CNMAP_CHANNEL_LUMINANCE:
271         break;
272
273     default:
274         return E_INVALIDARG;
275     }
276
277     if ( IsCompressed( srcImage.format ) || IsTypeless( srcImage.format ) )
278         return HRESULT_FROM_WIN32( ERROR_NOT_SUPPORTED );
279
280     // Setup target image
281     normalMap.Release();
282
283     HRESULT hr = normalMap.Initialize2D( format, srcImage.width, srcImage.height, 1, 1 );
284     if ( FAILED(hr) )
285         return hr;
286
287     const Image *img = normalMap.GetImage( 0, 0, 0 );
288     if ( !img )
289     {
290         normalMap.Release();
291         return E_POINTER;
292     }
293
294     hr = _ComputeNMap( srcImage, flags, amplitude, format, *img );
295     if ( FAILED(hr) )
296     {
297         normalMap.Release();
298         return hr;
299     }
300
301     return S_OK;
302 }
303
304 HRESULT ComputeNormalMap( const Image* srcImages, size_t nimages, const TexMetadata& metadata,
305                           DWORD flags, float amplitude, DXGI_FORMAT format, ScratchImage& normalMaps )
306 {
307     if ( !srcImages || !nimages )
308         return E_INVALIDARG;
309
310     if ( !IsValid(format) || IsCompressed(format) || IsTypeless(format) )
311         return E_INVALIDARG;
312
313     static_assert( CNMAP_CHANNEL_RED == 0x1, "CNMAP_CHANNEL_ flag values don't match mask" );
314     switch( flags & 0xf )
315     {
316     case 0:
317     case CNMAP_CHANNEL_RED:
318     case CNMAP_CHANNEL_GREEN:
319     case CNMAP_CHANNEL_BLUE:
320     case CNMAP_CHANNEL_ALPHA:
321     case CNMAP_CHANNEL_LUMINANCE:
322         break;
323
324     default:
325         return E_INVALIDARG;
326     }
327
328     normalMaps.Release();
329
330     TexMetadata mdata2 = metadata;
331     mdata2.format = format;
332     HRESULT hr = normalMaps.Initialize( mdata2 );
333     if ( FAILED(hr) )
334         return hr;
335
336     if ( nimages != normalMaps.GetImageCount() )
337     {
338         normalMaps.Release();
339         return E_FAIL;
340     }
341
342     const Image* dest = normalMaps.GetImages();
343     if ( !dest )
344     {
345         normalMaps.Release();
346         return E_POINTER;
347     }
348
349     for( size_t index=0; index < nimages; ++index )
350     {
351         assert( dest[ index ].format == format );
352
353         const Image& src = srcImages[ index ];
354         if ( IsCompressed( src.format ) || IsTypeless( src.format ) )
355         {
356             normalMaps.Release();
357             return HRESULT_FROM_WIN32( ERROR_NOT_SUPPORTED );
358         }
359
360         if ( src.width != dest[ index ].width || src.height != dest[ index ].height )
361         {
362             normalMaps.Release();
363             return E_FAIL;
364         }
365
366         hr = _ComputeNMap( src, flags, amplitude, format, dest[ index ] );
367         if ( FAILED(hr) )
368         {
369             normalMaps.Release();
370             return hr;
371         }
372     }
373
374     return S_OK;
375 }
376
377 }; // namespace