source: GTP/trunk/App/Demos/Illum/Shark3D/version164x12u/IllumDemo/src/gtp_shader/gtp_shader_envmap.cpp @ 2196

Revision 2196, 20.1 KB checked in by szirmay, 17 years ago (diff)
Line 
1///////////////////////////////////////////////////////////////////////////////
2//
3//      ##  ######
4//       ######  ###
5//  ## ###############        Shark 3D Engine (www.shark3d.com)
6//   ########## # # #
7//    ########                Copyright (c) 1996-2006 Spinor GmbH.
8//   ######### # # #          All rights reserved.
9//  ##   ##########
10//      ##
11//
12///////////////////////////////////////////////////////////////////////////////
13
14//@cpp
15
16#include "gtp_shader_envmap.h"
17#include "gtp_shader_opticsutil.h"
18#include "../../interf/eng_pos.h"
19#include "../../interf/eng_gfxvar.h"
20#include "../../interf/eng_gfxport.h"
21#include "../../util/eng_util_gfxutil.h"
22#include "../../util/eng_util_gfxbegin.h"
23#include "../../util/eng_util_gfxelemjobbegin.h"
24#include "../../util/eng_util_mathutil.h"
25#include "../../util/eng_util_shaderutil.h"
26#include "../../util/eng_util_shaderitemjob.h"
27#include "../../../drv/interf/drv_vartypes.h"
28#include "../../../drv/util/drv_util_varutil.h"
29#include "../../../drv/util/drv_util_gfxutil.h"
30#include "../../../util/math/util_geo_types.h"
31#include "../../../util/snk/util_snk_extractutil.h"
32
33///////////////////////////////////////////////////////////////////////////////
34/*@{
35
36@declare{shader.class}{gtp_shader.envmap}{}
37
38@}*/
39///////////////////////////////////////////////////////////////////////////////
40
41S3D_UTIL_RTTI_TABLE_DEFINE_BEGIN(gtp_Shader_EnvMap)
42S3D_UTIL_RTTI_TABLE_DEFINE_BASE(s3d_CEngShader)
43S3D_UTIL_RTTI_TABLE_DEFINE_BASE(s3d_CCompUtilUniqueBase)
44S3D_UTIL_RTTI_TABLE_DEFINE_BASE(s3d_CCompSetup)
45S3D_UTIL_RTTI_TABLE_DEFINE_END
46
47gtp_Shader_EnvMap::gtp_Shader_EnvMap()
48{
49}
50
51void gtp_Shader_EnvMap::SetupInit(
52        s3d_CUtilMsgHandler *MsgHandler, s3d_CUtilStr_cr Info,
53        s3d_CCompSuppl *FetchSuppl, s3d_CUtilSnkChunk *Param)
54{
55    m_Data = S3D_SYS_NEW gtp_Shader_EnvMapData;
56
57    s3d_CUtilSnkExtract SnkExtract;
58    SnkExtract.Assign(MsgHandler, Param);
59    m_Data->m_Info = SnkExtract.GetInfo();
60   
61    /*@{ @declare{shader.param}{eng_shader_special.envmap.env}{$ [str]}
62    @}*/
63    s3d_CUtilStr EnvIdent, EnvInfo;
64    SnkExtract.ExtractStr(EnvInfo, EnvIdent, "env", true);
65
66    m_ShaderEnv = s3d_CompSupplObjT<s3d_CEngShaderEnv>(
67            MsgHandler, EnvInfo, FetchSuppl,
68            EnvIdent, S3D_GENERAL_INTEROP_INTERF);
69    if(!m_ShaderEnv)
70        return;
71
72    /*@{ @declare{shader.param}{eng_shader_special.envmap.methods}
73            {$ [str] .. [str]}
74    @}*/
75    s3d_CUtilSnkExtractUtil::ExtractAtomSortedArray(
76            m_Data->m_MethodArray, m_ShaderEnv->m_AtomMgr,
77            SnkExtract, "methods", true);
78
79    /*@{ @declare{shader.param}{eng_shader_special.envmap.rank}{$ [int]}
80        See @ref{prog_man.shader.ranks}.
81    @}*/
82    SnkExtract.ExtractInt(
83            m_Data->m_RankInfo, m_Data->m_Rank, "rank", true);
84
85    /*@{ @declare{shader.param}{eng_shader_special|envmap.proj_neg_z}
86            {$ [float]}
87        See @ident{comp}{kit_engbase.gfxport}.
88    @}*/
89    m_Data->m_NegZ = SnkExtract.ExtractFloat("proj_neg_z", true);
90
91    /*@{ @declare{shader.param}{eng_shader_special|envmap.proj_pos_z}
92            {$ [float]}
93        See @ident{comp}{kit_engbase.gfxport}.
94    @}*/
95    m_Data->m_PosZ = SnkExtract.ExtractFloat("proj_pos_z", true);
96
97    /*@{ @declare{shader.param}{eng_shader_special|envmap.max_ext}{$ [int]}
98        Maximal texture width and heigth.
99    @}*/
100    m_Data->m_MaxExt = SnkExtract.ExtractInt("max_ext", true);
101
102    /*@{ @declare{shader.param}{eng_shader_special|envmap.ext_dist_scale}
103            {$ [float]}
104        Distance factor.
105        At larger distance a smaller texture is used.
106        If this factor is larger, a larger texture is used
107        also at larger distances.
108        Note that the texture is never larger than
109        @ident{comp}{eng_shader_special|envmap.max_ext}.
110    @}*/
111    m_Data->m_ExtDistScale = SnkExtract.ExtractFloat("ext_dist_scale", true);
112
113    /*@{ @declare{shader.param}{eng_shader_special.envmap.max_recursion}
114            {$ [int]}
115        See @ident{comp}{eng_shader_special.opticsdirect.max_recursion}.
116    @}*/
117    m_Data->m_MaxRecursion = SnkExtract.ExtractInt("max_recursion", true);
118
119    /*@{ @declare{shader.param}{eng_shader_special.envmap.enum_trigger}
120            {$ [str]}
121        Trigger used for rendering the mirror image.
122    @}*/
123    m_Data->m_EnumTrigger = s3d_CUtilSnkExtractUtil::ExtractAtom(
124            m_ShaderEnv->m_AtomMgr, SnkExtract, "enum_trigger", true);
125
126    /*@{ @declare{shader.param}{eng_shader_special.envmap.mesh_var}{$ [str]}
127    @}*/
128    s3d_CUtilSnkExtractUtil::ExtractAtom(
129            m_Data->m_MeshVarInfo, m_Data->m_MeshVarAtom,
130            m_ShaderEnv->m_AtomMgr, SnkExtract, "mesh_var", true);
131
132    m_Data->m_DestProp = 0;
133
134    /*@{ @declare{shader.param}
135            {eng_shader_special.envmap.destprop_antialias}{$ [bool]}
136        Render the main rendering
137        of @ident{comp}{eng_shader_special.envmap.dest_array}
138        with antialiasing.
139    @}*/
140    if(SnkExtract.ExtractBool("destprop_antialias", true))
141        m_Data->m_DestProp |= s3d_CDrvGfxEng::DestProp_Antialias;
142
143    /*@{ @declare{shader.param}{eng_shader_special.envmap.dest_array}
144            {$ [chunk]..[chunk]}
145        See @ident{comp}{<dest_array>}.
146    @}*/
147    s3d_CUtilSnkChunkArray DestChunkArray;
148    SnkExtract.ExtractChunkArray(DestChunkArray, "dest_array", true);
149
150        m_Data->m_UpdateAllFace = SnkExtract.ExtractBool("update_all_face", true, true);
151        m_Data->m_WorldSpace = SnkExtract.ExtractBool("world_space", true, false);
152        m_Data->m_UpdateInterval = SnkExtract.ExtractInt("update_interval", true, 1);
153        m_Data->m_StartFrame = SnkExtract.ExtractInt("start_frame", true, 0);
154       
155        s3d_CUtilSnkExtractUtil::ExtractAtom(
156    m_Data->m_LastCenterVarInfo, m_Data->m_LastCenterVarAtom,
157    m_ShaderEnv->m_AtomMgr, SnkExtract, "last_center_var", true);
158
159    SnkExtract.CheckForUnknown();
160
161    int ExtraTexProp = s3d_CDrvGfxEng::TexProp_Cube;
162    int ExtraSampMode = 0;
163    m_Data->m_Dest.Init(m_ShaderEnv, ExtraTexProp,
164            ExtraSampMode, DestChunkArray);
165}
166
167void gtp_Shader_EnvMap::SetupDone()
168{
169}
170
171s3d_CUtilStr gtp_Shader_EnvMap::GetInfo()
172{
173    return m_Data->m_Info;
174}
175
176void gtp_Shader_EnvMap::RegisterNotif(s3d_CUtilNotifRecip *Recip)
177{
178}
179
180s3d_CEngShaderGfxPtr gtp_Shader_EnvMap::FindShaderGfx(
181        s3d_CUtilNotifGather *NotifGather, s3d_CEngGfxCtx *GfxCtx)
182{
183    if(!m_ShaderEnv)
184        return 0;
185
186    gtp_Shader_EnvMapGfxPtr ShaderGfx;
187    gtp_Shader_EnvMapGfxTree::CNode *Pos
188            = s3d_UtilTreeSortedGetStart(m_ShaderGfxTree, GfxCtx);
189    if(s3d_UtilTreeIsEqualAt(Pos, GfxCtx))
190        ShaderGfx = Pos->m_Data.m_Val;
191    else
192    {
193        ShaderGfx = S3D_SYS_NEW gtp_Shader_EnvMapGfx(
194                m_ShaderEnv, GfxCtx, m_Data);
195        gtp_Shader_EnvMapGfxTree::CNode *Node
196                = ShaderGfx->GetNode();
197        m_ShaderGfxTree.InsertBefore(Pos, Node);
198    }
199    return ShaderGfx.Get();
200}
201
202///////////////////////////////////////////////////////////////////////////////
203
204gtp_Shader_EnvMapGfx::gtp_Shader_EnvMapGfx(
205        s3d_CEngShaderEnv *ShaderEnv,
206        s3d_CEngGfxCtx *GfxCtx,
207        gtp_Shader_EnvMapData *Data)
208{
209    m_Node.m_Data.m_Key = GfxCtx;
210    m_Node.m_Data.m_Val = this;
211    m_ShaderEnv = ShaderEnv;
212    m_Data = Data;
213
214    m_DestGfx.Init(ShaderEnv, GfxCtx);
215}
216
217gtp_Shader_EnvMapGfxTree::CNode
218        *gtp_Shader_EnvMapGfx::GetNode()
219{
220    return &m_Node;
221}
222
223void gtp_Shader_EnvMapGfx::RegisterNotif(
224        s3d_CUtilNotifRecip *Recip)
225{
226}
227
228void gtp_Shader_EnvMapGfx::ExtractGfx()
229{
230    m_Node.Extract();
231}
232
233bool gtp_Shader_EnvMapGfx::IsValid()
234{
235    return true;
236}
237
238void gtp_Shader_EnvMapGfx::LinkCollect(
239        s3d_CUtilAtomSet &VarAtomSet)
240{
241    s3d_CDrvUtilVarUtil::LinkCollect(
242            VarAtomSet, m_Data->m_MeshVarAtom);
243    m_DestGfx.LinkCollect(VarAtomSet, m_Data->m_Dest);
244       
245        s3d_CDrvUtilVarUtil::LinkCollect(
246            VarAtomSet, m_Data->m_LastCenterVarAtom);
247}
248
249void gtp_Shader_EnvMapGfx::LinkAppoint(
250        s3d_CDrvVarDecl *VarDecl)
251{
252    s3d_CDrvUtilVarUtil::LinkAppoint(
253            m_MeshVarSlot.m_Val,
254            VarDecl, m_Data->m_MeshVarAtom);
255    m_DestGfx.LinkAppoint(VarDecl, m_Data->m_Dest);
256
257        s3d_CDrvUtilVarUtil::LinkAppoint(
258            m_LastCenterVarSlot.m_Val,
259            VarDecl, m_Data->m_LastCenterVarAtom);
260}
261
262s3d_CEngShaderInstPtr gtp_Shader_EnvMapGfx::CreateShaderInst(
263        s3d_CEngShaderHead *Head)
264{
265    s3d_CEngGfxCtx *GfxCtx = m_Node.m_Data.m_Key;
266    return S3D_SYS_NEW gtp_Shader_EnvMapInst(
267            m_ShaderEnv, GfxCtx, Head, this);
268}
269
270///////////////////////////////////////////////////////////////////////////////
271
272gtp_Shader_EnvMapInst::gtp_Shader_EnvMapInst(
273        s3d_CEngShaderEnv *ShaderEnv,
274        s3d_CEngGfxCtx *GfxCtx, s3d_CEngShaderHead *Head,
275        gtp_Shader_EnvMapGfx *ShaderGfx)
276{
277        m_FrameCount = 0;
278        if(ShaderGfx->m_Data->m_UpdateInterval > 0)
279        m_FrameCount = ShaderGfx->m_Data->m_StartFrame
280                                                % ShaderGfx->m_Data->m_UpdateInterval;
281        m_CurrentFace = 0;
282    m_ShaderEnv = ShaderEnv;
283    m_GfxCtx = GfxCtx;
284    m_Head = Head;
285    m_ShaderGfx = ShaderGfx;
286    m_CanRenderColorAlphaTex = false;
287   
288    if(GfxCtx)
289    {
290        if(s3d_CDrvUtilGfxUtil::HasCap(
291                GfxCtx->m_GfxEng, S3D_DRV_GFX_CAP_RENDER_TEX_COLORALPHA))
292            m_CanRenderColorAlphaTex = true;
293    }
294}
295
296void gtp_Shader_EnvMapInst::RegisterNotif(
297        s3d_CUtilNotifRecip *Recip)
298{
299}
300
301void gtp_Shader_EnvMapInst::SetShaderCtx(
302        s3d_CEngShaderCtx *ShaderCtx)
303{
304}
305
306void gtp_Shader_EnvMapInst::SetGfxState(
307        s3d_CEngGfxState *GfxState)
308{
309}
310
311void gtp_Shader_EnvMapInst::SetPos(s3d_CEngPos *Pos)
312{
313}
314
315void gtp_Shader_EnvMapInst::SetModel(s3d_CEngModel *Model)
316{
317}
318
319void gtp_Shader_EnvMapInst::ArrangeCollect(
320        s3d_CUtilMemPool *MemPool,
321        s3d_CEngShaderScopeArray &ScopeArray)
322{
323}
324
325void gtp_Shader_EnvMapInst::ArrangeInit(
326        s3d_CUtilMemPool *MemPool,
327        s3d_CEngShaderScopeArray_cr ScopeArray)
328{
329        s3d_CSysIntps nScope = ScopeArray.GetCnt();
330    s3d_CSysIntps iScope;
331    for(iScope = 0; iScope < nScope; iScope++)
332    {
333        s3d_CEngShaderScope *Scope = ScopeArray.GetAt(iScope);
334        SetVars(MemPool, Scope);
335    }
336}
337
338void gtp_Shader_EnvMapInst::ArrangePerform(
339        s3d_CUtilMemPool *MemPool,
340        s3d_CEngShaderScopeArray_cr ScopeArray)
341{
342}
343
344void gtp_Shader_EnvMapInst::ArrangeFeedback(
345        s3d_CUtilMemPool *MemPool,
346        s3d_CEngShaderScopeArray_cr ScopeArray)
347{
348}
349
350void gtp_Shader_EnvMapInst::ArrangeGather(
351        s3d_CEngShaderExecArray &ExecArray)
352{
353    gtp_Shader_EnvMapData *Data = m_ShaderGfx->m_Data;
354
355    s3d_CEngUtilShaderUtil::ArrangeGather(
356            ExecArray, Data->m_MethodArray, this);
357}
358
359void gtp_Shader_EnvMapInst::ShaderExecPerform(
360        s3d_CEngShaderScope *Scope,
361        s3d_CUtilAtom *Method,
362        s3d_CEngGfxTaskArray &TaskArray)
363{
364        gtp_Shader_EnvMapData *Data = m_ShaderGfx->m_Data;
365       
366        bool doRender = true;
367        if(Data->m_UpdateInterval > 1)
368        {
369                if(m_FrameCount == Data->m_UpdateInterval)
370                        m_FrameCount = 0;
371                m_FrameCount++;
372                if(!(m_FrameCount % Data->m_UpdateInterval == 1))       
373                        doRender = false;
374        }
375        if(Data->m_UpdateInterval < 0)
376                doRender = false;
377        if(Data->m_UpdateInterval == 0)
378        {
379                Data->m_UpdateInterval = -1;
380                Data->m_UpdateAllFace = true;
381        }
382
383    int Rank = Data->m_Rank;
384    if(Rank == 0)
385        doRender = false;
386
387        if(doRender)
388        {
389                s3d_CEngGfxElemJob *GfxElemJob = new(m_ShaderEnv->m_MemPool)
390                                s3d_CEngUtilShaderItemJob<gtp_Shader_EnvMapInst>(
391                                Scope, 0,
392                                this, &gtp_Shader_EnvMapInst::GfxElemJobExec);
393
394                s3d_CEngGfxTaskOrder KeyOrder = 0;
395                s3d_CEngUtilGfxUtil::AppendTask(
396                                m_ShaderEnv->m_MemPool, TaskArray, Rank, KeyOrder, GfxElemJob);
397        }
398        SetVars(m_ShaderEnv->m_MemPool, Scope);
399}
400
401void *gtp_Shader_EnvMapInst::GfxElemJobExec(
402        s3d_CEngShaderScope *Scope,
403        void *GfxMark)
404{
405       
406    gtp_Shader_EnvMapData *Data = m_ShaderGfx->m_Data;
407
408    if(!Scope)
409        return GfxMark;
410
411    s3d_CEngGfxPortion *Portion = Scope->m_Portion;
412    if(!Portion)
413        return GfxMark;
414
415    s3d_CUtilMemPool *MemPool = m_ShaderEnv->m_MemPool;
416
417    s3d_CEngGfxVarMesh *MeshVar = s3d_EngGfxVarFetchWaryMesh(
418            m_ShaderEnv->m_MsgHandler, Scope->m_Info,
419            Scope->m_VarBlk, m_ShaderGfx->m_MeshVarSlot.m_Val);
420    if(!MeshVar)
421        return GfxMark;
422
423    s3d_CUtilTranslQuatf ViewTransf = MeshVar->m_Val.m_ViewTransf;
424    s3d_CUtilVec3f BoundCen = MeshVar->m_Val.m_MeshCompos.m_BoundCen;
425    s3d_CUtilVec3f BoundExt = MeshVar->m_Val.m_MeshCompos.m_BoundExt;
426
427        s3d_CEngUtilShaderDestJob *DestJob = 0;
428
429        Calc(MemPool, Scope, ViewTransf, BoundCen, BoundExt, DestJob);
430
431    s3d_CEngUtilShaderDestGfx *DestGfx = &m_ShaderGfx->m_DestGfx;
432    DestGfx->FinishJob(m_ShaderEnv, Scope, Data->m_Dest, DestJob);
433
434    return 0;
435}
436
437
438
439void gtp_Shader_EnvMapInst::Calc(
440        s3d_CUtilMemPool *MemPool, s3d_CEngShaderScope *Scope,
441        s3d_CUtilTranslQuatf_cr ViewTransf,
442        s3d_CUtilVec3f_cr BoundCen, s3d_CUtilVec3f_cr BoundExt,
443        s3d_CEngUtilShaderDestJob *&DestJob)
444{
445    DestJob = 0;
446    gtp_Shader_EnvMapData *Data = m_ShaderGfx->m_Data;
447    s3d_CEngUtilShaderDestGfx *DestGfx = &m_ShaderGfx->m_DestGfx;
448
449    s3d_CEngGfxPortion *Portion = Scope->m_Portion;
450    if(!Portion)
451        return;
452    s3d_CEngGfxCycle *Cycle = Portion->m_Cycle;
453    if(!Cycle)
454        return;
455    s3d_CEngGfxRun *Run = Cycle->m_Run;
456    if(!Run)
457        return;
458    s3d_CDrvGfxEng *GfxEng = Run->m_GfxEng;
459    if(!GfxEng)
460        return;
461   
462    s3d_CEngGfxPort *Port = s3d_UtilRecogCastCheck<s3d_CEngGfxPort>(
463            m_ShaderEnv->m_MsgHandler, Data->m_RankInfo,
464            Portion->m_Port);
465    if(!Port)
466        return;
467
468    if(!m_CanRenderColorAlphaTex)
469        return;
470
471        s3d_CEngGfxCam *Cam = &Portion->m_Cam;
472
473        if(Data->m_WorldSpace)
474         m_LastCenter = s3d_CUtilVec4f(Cam->m_Transf.ApplyToPoint(
475                                                        ViewTransf.ApplyToPoint(BoundCen)),1);
476        else
477         m_LastCenter = s3d_CUtilVec4f(ViewTransf.ApplyToPoint(BoundCen),1);
478
479   
480    // Check if rendering into texture is possible:
481
482    if(!s3d_CEngUtilGfxUtil::VerifyGfxClosed(
483            m_ShaderEnv->m_MsgHandler, Data->m_RankInfo.GetChars(),
484            Portion->m_Cycle))
485    {
486        Data->m_Rank = 0; // Avoid the error being reported each frame
487        return;
488    }
489
490    // Check recursion level:
491    if(Cam->m_Recursion >= Data->m_MaxRecursion)
492        return;
493
494    // Calculate texture size:
495    float EffWidth = Cam->m_TotWidth * Cam->m_ViewPane.m_Scale.m_x;
496    float EffHeight = Cam->m_TotHeight * Cam->m_ViewPane.m_Scale.m_y;
497    float CamExt = s3d_SysMax(EffWidth, EffHeight);
498    float Dist = ViewTransf.m_Transl.GetLen();
499    int RawTexExt = s3d_SysIntOfFloatNearest(
500            Data->m_ExtDistScale * CamExt / Dist);
501    int WantTexExt = gtp_ShaderOpticsUtil::RoundToPowerOfTwoUp(
502                                RawTexExt);
503    if(WantTexExt > Data->m_MaxExt)
504        WantTexExt = Data->m_MaxExt;
505
506    int TexProp = 0;
507    if(!DestGfx->GetSnapTexPropWidthHeight(
508                m_ShaderEnv, Scope, Data->m_Dest,
509                WantTexExt, WantTexExt, TexProp))
510        return;
511
512    int TexWidth = WantTexExt;
513    int TexHeight = WantTexExt;
514    int TexDepth = 1;
515    int TexSnap = s3d_CDrvGfxEng::TexSnap_PreferUp;
516    GfxEng->SnapTexSize(TexWidth, TexHeight, TexDepth, TexProp, TexSnap);
517
518        /////////////////
519    // Allocate texture:
520    DestJob = DestGfx->CreateJob(
521                m_ShaderEnv, Scope, Data->m_Dest, TexWidth, TexHeight);
522    if(!DestJob)
523        return;
524
525    static const int CubeFaceMap[] =
526    {
527        s3d_CDrvGfxEng::TexPart_CubePosX, s3d_CDrvGfxEng::TexPart_CubeNegX,
528        s3d_CDrvGfxEng::TexPart_CubePosY, s3d_CDrvGfxEng::TexPart_CubeNegY,   
529        s3d_CDrvGfxEng::TexPart_CubePosZ, s3d_CDrvGfxEng::TexPart_CubeNegZ,
530    };
531    static const s3d_CUtilVec3f ViewDirMap[] =
532    {
533        s3d_CUtilVec3f( 1.f, 0.f, 0.f), s3d_CUtilVec3f(-1.f,  0.f,  0.f),
534        s3d_CUtilVec3f( 0.f, 1.f, 0.f), s3d_CUtilVec3f( 0.f, -1.f,  0.f),
535        s3d_CUtilVec3f( 0.f, 0.f, 1.f), s3d_CUtilVec3f( 0.f,  0.f, -1.f), 
536    };
537
538    static const s3d_CUtilVec3f AlsoFromMap[] =
539    {
540        s3d_CUtilVec3f( 1.f, 0.f, 0.f), s3d_CUtilVec3f( 1.f,  0.f, 0.f),
541        s3d_CUtilVec3f( 0.f, 1.f, 0.f), s3d_CUtilVec3f( 0.f,  1.f, 0.f),
542        s3d_CUtilVec3f( 1.f, 0.f, 0.f), s3d_CUtilVec3f( 1.f,  0.f, 0.f),
543    };
544    static const s3d_CUtilVec3f AlsoToMap[] =
545    {
546        s3d_CUtilVec3f( 0.f,  0.f, -1.f), s3d_CUtilVec3f(  0.f, 0.f, 1.f), 
547        s3d_CUtilVec3f( 0.f,  0.f, -1.f), s3d_CUtilVec3f(  0.f, 0.f, 1.f), 
548        s3d_CUtilVec3f( 1.f,  0.f,  0.f), s3d_CUtilVec3f( -1.f, 0.f, 0.f),
549    };
550
551    // Camera:
552    s3d_CEngGfxCam ChildCam(*Cam);
553    ChildCam.m_ViewPane = 1;
554    ChildCam.m_ViewDepthStart = 0;
555    ChildCam.m_ViewDepthEnd = 1;
556    ChildCam.m_TotWidth = TexWidth;
557    ChildCam.m_TotHeight = TexHeight;
558    ChildCam.m_Proj = s3d_CEngUtilMathUtil::CalcProjStd(
559            false, 1, -1, 0, 0, Data->m_NegZ, Data->m_PosZ);
560    ChildCam.m_Reverse = true;
561    ChildCam.m_Recursion = ChildCam.m_Recursion + 1;
562
563    // Move record cam to object center
564    s3d_CUtilTranslQuatf TranslQuat = Cam->m_Transf.Concat(ViewTransf);
565    ChildCam.m_Transf.m_Transl = TranslQuat.m_Transl;
566    ChildCam.m_BasePoint = ChildCam.m_Transf.m_Transl;
567    ChildCam.m_VisibPoint = ChildCam.m_BasePoint;
568    ChildCam.m_Exclude = m_Head;
569
570    // Rendering:
571    s3d_CDrvGfxDest *Dest = DestJob->m_DrvGfxDestArray.GetPtrRaw();
572    s3d_CSysIntps nDestTex = DestJob->m_DrvGfxDestArray.GetCnt();
573    s3d_CEngUtilGfxBeginTex *GfxBegin
574            = new(m_ShaderEnv->m_MemPool) s3d_CEngUtilGfxBeginTex(
575                    GfxEng, TexWidth, TexHeight, nDestTex, Dest, 1);
576
577    const s3d_CUtilVec3f CamDir(0, 0, 1);
578   
579        s3d_CUtilQuatf BaseQuat;
580        if(!Data->m_WorldSpace)
581                BaseQuat = Cam->m_Transf.m_Quat;
582        else
583                BaseQuat = s3d_CUtilQuatf(1,0,0,1);
584
585
586    s3d_CEngGfxTaskArray ChildTaskArray;
587    int iFace;
588        //framecount++;
589        //framecount = framecount % 6; 
590        //iFace = framecount;
591    for(iFace = 0; iFace < 6; iFace++)
592    {
593                if(!Data->m_UpdateAllFace)
594                {
595                        iFace = m_CurrentFace;
596                        m_CurrentFace = (++m_CurrentFace) % 6;
597                }
598
599        s3d_CSysIntps iDestTex = 0;
600        for(iDestTex = 0; iDestTex < nDestTex; iDestTex++)
601            Dest[iDestTex].m_Part = CubeFaceMap[iFace];
602               
603                s3d_CUtilQuatf EffQuat;
604                if(Data->m_WorldSpace)
605                        EffQuat = s3d_CUtilQuatf::ByPathAlso(
606                CamDir, ViewDirMap[iFace], AlsoFromMap[iFace],
607                        AlsoToMap[iFace]);
608                else
609                        EffQuat = BaseQuat * s3d_CUtilQuatf::ByPathAlso(
610                CamDir, ViewDirMap[iFace], AlsoFromMap[iFace],
611                        AlsoToMap[iFace]);
612               
613        ChildCam.m_Transf.m_Quat = EffQuat;
614
615        s3d_CEngGfxCycle *ChildCycle = Port->CollectNewCycle(
616                Run, ChildCam, Data->m_EnumTrigger, ChildTaskArray);
617        s3d_CEngUtilGfxElemJobBegin::AddGfxBegin(
618                m_ShaderEnv->m_MsgHandler, Data->m_RankInfo.GetChars(),
619                ChildCycle, Data->m_DestProp, ChildCam.m_ClearParam,
620                ChildTaskArray, GfxBegin);
621        s3d_CEngUtilGfxUtil::PerformChild(
622                Cycle, ChildCycle, ChildTaskArray);
623        s3d_CEngUtilGfxUtil::CloseGfxTex(
624                m_ShaderEnv->m_MsgHandler, Data->m_RankInfo.GetChars(),
625                Cycle, GfxBegin);
626        ChildTaskArray.Clear();
627
628                if(!Data->m_UpdateAllFace)
629                        break;
630    }
631    ChildTaskArray.Reset();
632}
633
634void gtp_Shader_EnvMapInst::SetVars(
635        s3d_CUtilMemPool *MemPool, s3d_CEngShaderScope *Scope)
636{
637        gtp_Shader_EnvMapData *Data = m_ShaderGfx->m_Data;
638
639    s3d_CDrvVarSlot LastCenterVarSlot = m_ShaderGfx->m_LastCenterVarSlot;
640    if(LastCenterVarSlot >= 0)
641    {
642                s3d_CDrvVarVec4f *ValVar = new(MemPool) s3d_CDrvVarVec4f;
643                ValVar->m_Val = m_LastCenter;
644        s3d_DrvVarSet(Scope->m_VarBlk, LastCenterVarSlot, ValVar);
645    }
646}
647///////////////////////////////////////////////////////////////////////////////
Note: See TracBrowser for help on using the repository browser.