1 /*---------------------------------------------------------------------------*
2   Project:  NintendoWare
3   File:     gfx_ResMaterial.cpp
4 
5   Copyright (C)2009-2010 Nintendo Co., Ltd./HAL Laboratory, Inc.  All rights reserved.
6 
7   These coded instructions, statements, and computer programs contain
8   proprietary information of Nintendo of America Inc. and/or Nintendo
9   Company Ltd., and are protected by Federal copyright law.  They may
10   not be disclosed to third parties or copied or duplicated in any form,
11   in whole or in part, without the prior written consent of Nintendo.
12 
13   $Revision: 18139 $
14  *---------------------------------------------------------------------------*/
15 
16 #include "../precompiled.h"
17 
18 #include <nw/gfx/res/gfx_ResUtil.h>
19 #include <nw/gfx/res/gfx_ResMaterial.h>
20 #include <nw/gfx/res/gfx_ResGraphicsFile.h>
21 
22 namespace nw {
23 namespace gfx {
24 namespace res {
25 
26 static Result
27 SetupTextureCoordinators(ResMaterial resMaterial);
28 
29 //----------------------------------------------------------------------------
30 Result
Setup(os::IAllocator * allocator,ResGraphicsFile graphicsFile)31 ResMaterial::Setup(os::IAllocator* allocator, ResGraphicsFile graphicsFile)
32 {
33     NW_ASSERT( internal::ResCheckRevision( graphicsFile ) );
34     NW_ASSERT( internal::ResCheckRevision( *this ) );
35 
36     NW_ASSERT( this->IsValid() );
37 
38     Result result = RESOURCE_RESULT_OK;
39 
40     result |= this->SetupTextures(allocator, *this, graphicsFile);
41 
42     // Shaderをセットアップします。
43     result |= this->SetupShader(allocator, this->GetShader(), graphicsFile);
44 
45     // ユーザーシェーダーユニフォームのインデックス番号をキャッシュします。
46     ResShader resShader = this->GetShader();
47     if (resShader.IsValid() && ((result.GetDescription() & nw::gfx::RESOURCE_RESULT_NOT_FOUND_SHADER) == 0))
48     {
49         ResBinaryShader resBinaryShader = resShader.Dereference();
50         NW_MINMAXLT_ASSERT(this->GetShaderProgramDescriptionIndex(), 0, resBinaryShader.GetDescriptionsCount());
51 
52         ResShaderProgramDescription description =
53             resBinaryShader.GetDescriptions(this->GetShaderProgramDescriptionIndex());
54         this->CacheUserUniformIndex(description.GetSymbols());
55     }
56 
57     // FragmentLightingTableをセットアップします。
58     ResFragmentShader resFragmentShader = this->GetFragmentShader();
59     NW_ASSERT(resFragmentShader.GetFragmentLightingTable().IsValid());
60     result |= resFragmentShader.Setup(allocator, graphicsFile);
61 
62     // フラグメントライティングテーブルのハッシュを計算します。
63     if ((result.GetDescription() & nw::gfx::RESOURCE_RESULT_NOT_FOUND_LUT) == 0)
64     {
65         // 必ず参照解決が完了している状態で呼び出す必要があります。
66         this->CalcFragmentLightingTableHash();
67     }
68 
69     return result;
70 }
71 
72 //----------------------------------------------------------------------------
73 void
Cleanup()74 ResMaterial::Cleanup()
75 {
76     int textureMapperNum = this->GetTextureMappersCount();
77     for ( int i = 0; i < textureMapperNum; ++i )
78     {
79         ResPixelBasedTextureMapper textureMapper = this->GetTextureMappers( i );
80         if (textureMapper.IsValid())
81         {
82             textureMapper.Cleanup();
83         }
84     }
85 
86     if (this->GetProceduralTextureMapper().IsValid())
87     {
88         this->GetProceduralTextureMapper().Cleanup();
89     }
90 
91     ResShader resShader = this->GetShader();
92     ut::SafeCleanup(resShader);
93 
94     ut::SafeCleanup(this->GetFragmentShader());
95 }
96 
97 //----------------------------------------
98 Result
SetupTextures(os::IAllocator * allocator,ResMaterial resMaterial,ResGraphicsFile graphicsFile)99 ResMaterial::SetupTextures(os::IAllocator* allocator, ResMaterial resMaterial, ResGraphicsFile graphicsFile)
100 {
101     Result result = RESOURCE_RESULT_OK;
102 
103     s32 textureMapperNum = resMaterial.GetTextureMappersCount();
104     result |= SetupTextureCoordinators(resMaterial);
105 
106     u32 textureSamplersHash = resMaterial.GetTextureSamplersHash();
107     // TextureMapper をセットアップします。
108     for ( int i = 0; i < textureMapperNum; ++i )
109     {
110         ResPixelBasedTextureMapper resTextureMapper = resMaterial.GetTextureMappers( i );
111         if (!resTextureMapper.IsValid())
112         {
113             continue;
114         }
115 
116         if (!resTextureMapper.GetTexture().IsValid())
117         {
118             continue;
119         }
120 
121         result |= resTextureMapper.Setup(allocator, graphicsFile);
122 
123         // テクスチャコーディネータを参照してテクスチャサンプラーのコマンドを設定する
124         enum
125         {
126             SAMPLER_TYPE_SHIFT = 28,
127             SAMPLER_TYPE_MASK = 0x7 << SAMPLER_TYPE_SHIFT,
128             SAMPLER_TYPE_2D = 0,
129             SAMPLER_TYPE_CUBE_MAP = 1,
130             SAMPLER_TYPE_SHADOW_2D = 2,
131             SAMPLER_TYPE_PROJECTION = 3,
132             SAMPLER_TYPE_SHADOW_CUBE = 4
133         };
134         u32* command = resTextureMapper.GetCommandCache();
135         NW_NULL_ASSERT(command);
136 
137         command[5] &= ~(SAMPLER_TYPE_MASK); // sampler_type
138         // テクスチャ０のみ複数のサンプラータイプが設定できる。
139         if ( i == 0 )
140         {
141             switch (resMaterial.GetTextureCoordinators(0).GetMappingMethod())
142             {
143             case ResTextureCoordinator::MAPPINGMETHOD_UV_COORDINATE:
144                 {
145                     command[5] |= SAMPLER_TYPE_2D << SAMPLER_TYPE_SHIFT;
146                 }
147                 break;
148             case ResTextureCoordinator::MAPPINGMETHOD_PROJECTION:
149                 {
150                     command[5] |= SAMPLER_TYPE_PROJECTION << SAMPLER_TYPE_SHIFT;
151                 }
152                 break;
153             case ResTextureCoordinator::MAPPINGMETHOD_CAMERA_CUBE_ENV:
154                 {
155                     command[5] |= SAMPLER_TYPE_CUBE_MAP << SAMPLER_TYPE_SHIFT;
156                 }
157                 break;
158             case ResTextureCoordinator::MAPPINGMETHOD_CAMERA_SPHERE_ENV:
159                 {
160                     command[5] |= SAMPLER_TYPE_2D << SAMPLER_TYPE_SHIFT;
161                 }
162                 break;
163             default:
164                 NW_FATAL_ERROR("Unsupported mapping method.");
165                 break;
166             }
167         }
168 
169         if ((result.GetDescription() & RESOURCE_RESULT_NOT_FOUND_TEXTURE) == 0)
170         {
171             ResTexture resImageTexture = resTextureMapper.GetTexture().Dereference();
172             u32 hash = 0;
173             if (i == 0)
174             {
175                 hash = (u32)resImageTexture.ptr();
176             }
177             else
178             {
179                 hash = ((u32)resImageTexture.ptr() << i * 8) | ((u32)resImageTexture.ptr() >> (32 - i * 8));
180             }
181 
182             textureSamplersHash ^= hash;
183         }
184     }
185 
186     resMaterial.SetTextureMappersHash(textureSamplersHash);
187 
188     if (resMaterial.GetProceduralTextureMapper().IsValid())
189     {
190         result |= resMaterial.GetProceduralTextureMapper().Setup(allocator, graphicsFile);
191     }
192 
193     return result;
194 }
195 
SetupTextureCoordinators(ResMaterial resMaterial)196 static Result SetupTextureCoordinators(ResMaterial resMaterial)
197 {
198     Result result = RESOURCE_RESULT_OK;
199 
200     // TextureMapper と TextureCoordinator の組み合わせを確認します。
201     s32 textureCoordinatorNum = resMaterial.GetTextureCoordinatorsCount();
202     ResMaterial::TextureCoordinateConfig config = resMaterial.GetTextureCoordinateConfig();
203     bool isProceduralTextureEnabled = resMaterial.GetProceduralTextureMapper().IsValid();
204     for ( int i = 0; i < textureCoordinatorNum; ++i )
205     {
206         ResTextureCoordinator resTextureCoordinator = resMaterial.GetTextureCoordinators(i);
207         bool isTextureMapperEnabled = resMaterial.GetTextureMappers(i).IsValid();
208         resTextureCoordinator.SetEnabled(false);
209 
210         switch(i)
211         {
212             case 0:
213             {
214                 if (isTextureMapperEnabled)
215                 {
216                     resTextureCoordinator.SetEnabled(true);
217                 }
218                 else if (config == ResMaterial::CONFIG_0120 || config == ResMaterial::CONFIG_0110)
219                 {
220                     if (isProceduralTextureEnabled)
221                     {
222                         resTextureCoordinator.SetEnabled(true);
223                     }
224                 }
225             }
226             break;
227             case 1:
228             {
229                 if (isTextureMapperEnabled)
230                 {
231                     resTextureCoordinator.SetEnabled(true);
232                 }
233                 else
234                 {
235                     if (config == ResMaterial::CONFIG_0111)
236                     {
237                         if (resMaterial.GetTextureMappers(2).IsValid() || isProceduralTextureEnabled)
238                         {
239                             resTextureCoordinator.SetEnabled(true);
240                         }
241                     }
242                     else if (config == ResMaterial::CONFIG_0110 || config == ResMaterial::CONFIG_0112)
243                     {
244                         if (resMaterial.GetTextureMappers(2).IsValid())
245                         {
246                             resTextureCoordinator.SetEnabled(true);
247                         }
248                     }
249                     else if (config == ResMaterial::CONFIG_0121)
250                     {
251                         if (isProceduralTextureEnabled)
252                         {
253                             resTextureCoordinator.SetEnabled(true);
254                         }
255                     }
256                 }
257             }
258             break;
259             case 2:
260             {
261                 if (config == ResMaterial::CONFIG_0122)
262                 {
263                     if (isTextureMapperEnabled || isProceduralTextureEnabled)
264                     {
265                         resTextureCoordinator.SetEnabled(true);
266                     }
267                 }
268                 else if (config == ResMaterial::CONFIG_0120 || config == ResMaterial::CONFIG_0121)
269                 {
270                     if (isTextureMapperEnabled)
271                     {
272                         resTextureCoordinator.SetEnabled(true);
273                     }
274                 }
275                 else if (config == ResMaterial::CONFIG_0112)
276                 {
277                     if (isProceduralTextureEnabled)
278                     {
279                         resTextureCoordinator.SetEnabled(true);
280                     }
281                 }
282             }
283             break;
284             default:
285             {
286                 NW_FATAL_ERROR("Invalid coordinator number.");
287             }
288         }
289     }
290     return result;
291 }
292 
293 //----------------------------------------
294 Result
SetupShader(os::IAllocator * allocator,ResShader resShader,ResGraphicsFile graphicsFile)295 ResMaterial::SetupShader(
296     os::IAllocator* allocator,
297     ResShader resShader,
298     ResGraphicsFile graphicsFile
299 )
300 {
301     Result result = RESOURCE_RESULT_OK;
302     ResShader setupShader;
303 
304     if (resShader.IsValid())
305     {
306         bool existShader = false;
307         ResReferenceShader refer = ResDynamicCast<ResReferenceShader>(resShader);
308         if (refer.IsValid())
309         {
310             if (refer.GetTargetShader().IsValid())
311             {
312                 setupShader = refer.GetTargetShader();
313                 existShader = true;
314             }
315             else
316             {
317                 ::std::pair<ResShader, bool> referenceResult;
318                 referenceResult = GetReferenceShaderTarget(refer, graphicsFile);
319                 if (referenceResult.second)
320                 {
321                     setupShader = referenceResult.first;
322                     existShader = true;
323                 }
324                 else
325                 {
326                     result |= Result::MASK_FAIL_BIT;
327                     result |= RESOURCE_RESULT_NOT_FOUND_SHADER;
328                 }
329             }
330         }
331         else
332         {
333             setupShader = resShader;
334             existShader = true;
335         }
336 
337         if (existShader)
338         {
339             result |= setupShader.Setup(allocator, graphicsFile);
340         }
341     }
342 
343     return result;
344 }
345 
346 //----------------------------------------
347 void
SetShader(ResShader resShader)348 ResMaterial::SetShader(ResShader resShader)
349 {
350     NW_ASSERT(resShader.IsValid());
351     ResReferenceShader referenceShader = ResStaticCast<ResReferenceShader>(this->GetShader());
352     referenceShader.ref().toTargetShader.set_ptr(resShader.Dereference().ptr());
353 }
354 
355 //----------------------------------------
356 void
CacheUserUniformIndex(ResShaderSymbolArray symbols)357 ResMaterial::CacheUserUniformIndex(ResShaderSymbolArray symbols)
358 {
359     for (int parameterIndex = 0; parameterIndex < this->GetShaderParametersCount(); ++parameterIndex)
360     {
361         ResShaderParameter parameter = this->GetShaderParameters(parameterIndex);
362         if (parameter.IsValid())
363         {
364             const char* name = parameter.GetName();
365 
366             if (name == NULL) { continue; }
367 
368             for (int symbolIndex = 0; symbolIndex < symbols.size(); ++symbolIndex)
369             {
370                 ResShaderSymbol shaderSymbol = symbols[symbolIndex];
371                 if (::std::strcmp(name, shaderSymbol.GetName()) == 0)
372                 {
373                     // ユーザーユニフォームのインデックスをキャッシュします。
374                     parameter.SetSymbolIndex(symbolIndex);
375                     break;
376                 }
377             }
378         }
379     }
380 }
381 
382 //----------------------------------------
383 void
CalcFragmentLightingTableHash()384 ResMaterial::CalcFragmentLightingTableHash()
385 {
386     enum
387     {
388         D0_SHIFT = 0,
389         D1_SHIFT = 4,
390         RR_SHIFT = 8,
391         RG_SHIFT = 12,
392         RB_SHIFT = 16,
393         FR_SHIFT = 20,
394         MAX_BITS = 32
395     };
396 
397     ResFragmentShader resFragmentShader = this->GetFragmentShader();
398     ResFragmentLightingTable resFragmentLightingTable = resFragmentShader.GetFragmentLightingTable();
399     NW_ASSERT(resFragmentLightingTable.IsValid());
400 
401     // FragmentLightingTableのハッシュ値を再計算します。
402     u32 fragmentLightingTableParametersHash = this->GetFragmentLightingTableParametersHash();
403 
404     if (resFragmentLightingTable.GetDistribution0Sampler().IsValid())
405     {
406         ResReferenceLookupTable refLut = ResDynamicCast<ResReferenceLookupTable>(resFragmentLightingTable.GetDistribution0Sampler().GetSampler());
407         if (refLut.IsValid())
408         {
409             ResImageLookupTable imageLut = refLut.Dereference();
410             fragmentLightingTableParametersHash ^= ((u32)imageLut.ptr()) << D0_SHIFT;
411         }
412     }
413 
414     if (resFragmentLightingTable.GetDistribution1Sampler().IsValid())
415     {
416         ResReferenceLookupTable refLut = ResDynamicCast<ResReferenceLookupTable>(resFragmentLightingTable.GetDistribution1Sampler().GetSampler());
417         if (refLut.IsValid())
418         {
419             ResImageLookupTable imageLut = refLut.Dereference();
420             fragmentLightingTableParametersHash ^=
421                 ((u32)imageLut.ptr() << D1_SHIFT) | ((u32)imageLut.ptr() >> (MAX_BITS - D1_SHIFT));
422         }
423     }
424 
425     if (resFragmentLightingTable.GetReflectanceRSampler().IsValid())
426     {
427         ResReferenceLookupTable refLut = ResDynamicCast<ResReferenceLookupTable>(resFragmentLightingTable.GetReflectanceRSampler().GetSampler());
428         if (refLut.IsValid())
429         {
430             ResImageLookupTable imageLut = refLut.Dereference();
431             fragmentLightingTableParametersHash ^=
432                 ((u32)imageLut.ptr() << RR_SHIFT) | ((u32)imageLut.ptr() >> (MAX_BITS - RR_SHIFT));
433         }
434     }
435 
436     if (resFragmentLightingTable.GetReflectanceGSampler().IsValid())
437     {
438         ResReferenceLookupTable refLut = ResDynamicCast<ResReferenceLookupTable>(resFragmentLightingTable.GetReflectanceGSampler().GetSampler());
439         if (refLut.IsValid())
440         {
441             ResImageLookupTable imageLut = refLut.Dereference();
442             fragmentLightingTableParametersHash ^=
443                 ((u32)imageLut.ptr() << RG_SHIFT) |
444                 ((u32)imageLut.ptr() >> (MAX_BITS - RG_SHIFT));
445         }
446     }
447 
448     if (resFragmentLightingTable.GetReflectanceBSampler().IsValid())
449     {
450         ResReferenceLookupTable refLut = ResDynamicCast<ResReferenceLookupTable>(resFragmentLightingTable.GetReflectanceBSampler().GetSampler());
451         if (refLut.IsValid())
452         {
453             ResImageLookupTable imageLut = refLut.Dereference();
454             fragmentLightingTableParametersHash ^=
455                 ((u32)imageLut.ptr() << RB_SHIFT) |
456                 ((u32)imageLut.ptr() >> (MAX_BITS - RB_SHIFT));
457         }
458     }
459 
460     if (resFragmentLightingTable.GetFresnelSampler().IsValid())
461     {
462         ResReferenceLookupTable refLut = ResDynamicCast<ResReferenceLookupTable>(resFragmentLightingTable.GetFresnelSampler().GetSampler());
463         if (refLut.IsValid())
464         {
465             ResImageLookupTable imageLut = refLut.Dereference();
466             fragmentLightingTableParametersHash ^=
467                 ((u32)imageLut.ptr() << FR_SHIFT) |
468                 ((u32)imageLut.ptr() >> (MAX_BITS - FR_SHIFT));
469         }
470     }
471 
472     this->SetFragmentLightingTableHash(fragmentLightingTableParametersHash);
473 }
474 
475 } /* namespace res */
476 } /* namespace gfx */
477 } /* namespace nw */
478 
479