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

///////////////////////////////////////////////////////////////////////////////
//
//      ##  ######
//       ######  ###
//  ## ###############        Shark 3D Engine (www.shark3d.com)
//   ########## # # #
//    ########                Copyright (c) 1996-2006 Spinor GmbH.
//   ######### # # #          All rights reserved.
//  ##   ##########
//      ##
//
///////////////////////////////////////////////////////////////////////////////

//@cpp

#include "gtp_shader_causticcube.h"
#include "../../interf/eng_gfxvar.h"
#include "../../util/eng_util_gfxutil.h"
#include "../../util/eng_util_gfxparamutil.h"
#include "../../util/eng_util_shaderutil.h"
#include "../../util/eng_util_shaderitemjob.h"
#include "../../../drv/interf/drv_vartypes.h"
#include "../../../drv/util/drv_util_varutil.h"
#include "../../../drv/util/drv_util_gfxutil.h"
#include "../../../drv/util/drv_util_paintprim.h"
#include "../../../util/snk/util_snk_extractutil.h"
#include "../../util/eng_util_mathutil.h"
#include "../../../util/math/util_geo_types.h"

///////////////////////////////////////////////////////////////////////////////
/*@{ 

@declare{shadercomp.class}{eng_shader_special.filter}{}

This component performs some iterative texture filtering.
@p

The component takes none, one or multiple source textures as input,
see @sident{comp}{eng_shader_special.filter.src_array}.
Then it passes them to a shaderprogram,
see @sident{comp}{eng_shader_special.filter.shaderprog_ident}.
Then it writes the result to none, one or multiple @em{destination} textures,
see @sident{comp}{eng_shader_special.filter.dest_array}.
@p

If the destination textures have already been allocated 
they are used "as is", but only if they all have the same size.
Otherwise temporary textures will fetched.
Their size is the maximum of the source textures scaled by
@sident{comp}{eng_shader_special.filter.width_scale} and
@sident{comp}{eng_shader_special.filter.height_scale}.
If necessary the destination texture size is @em{snapped}
to a value acceptable to the graphics card.
@p

@}*/
///////////////////////////////////////////////////////////////////////////////

S3D_UTIL_RTTI_TABLE_DEFINE_BEGIN(gtp_Shader_CausticCube)
S3D_UTIL_RTTI_TABLE_DEFINE_BASE(s3d_CEngShader)
S3D_UTIL_RTTI_TABLE_DEFINE_BASE(s3d_CCompUtilUniqueBase)
S3D_UTIL_RTTI_TABLE_DEFINE_BASE(s3d_CCompSetup)
S3D_UTIL_RTTI_TABLE_DEFINE_END

gtp_Shader_CausticCube::gtp_Shader_CausticCube()
{
}

void gtp_Shader_CausticCube::SetupInit(
        s3d_CUtilMsgHandler *MsgHandler, s3d_CUtilStr_cr Info,
        s3d_CCompSuppl *FetchSuppl, s3d_CUtilSnkChunk *Param)
{
    m_Data = S3D_SYS_NEW gtp_Shader_CausticCubeData;

    s3d_CUtilSnkExtract SnkExtract;
    SnkExtract.Assign(MsgHandler, Param);
    m_Data->m_Info = SnkExtract.GetInfo();
    
    /*@{ @declare{shadercomp.param}{eng_shader_special.filter.env}{$ [str]}
        See @ident{comp}{eng_shader_std.group.env}.
    @}*/
    s3d_CUtilStr EnvIdent, EnvInfo;
    SnkExtract.ExtractStr(EnvInfo, EnvIdent, "env", true);

    m_ShaderEnv = s3d_CompSupplObjT<s3d_CEngShaderEnv>(
            MsgHandler, EnvInfo, FetchSuppl, 
            EnvIdent, S3D_GENERAL_INTEROP_INTERF);
    if(!m_ShaderEnv)
        return;

    /*@{ @declare{shadercomp.param}
            {eng_shader_special.filter.methods}{$ [str] .. [str]}
        See @ref{prog_man.shader.methods}.
    @}*/
    s3d_CUtilSnkExtractUtil::ExtractAtomSortedArray(
            m_Data->m_MethodArray, m_ShaderEnv->m_AtomMgr, 
            SnkExtract, "methods", true);

    /*@{ @declare{shadercomp.param}
            {eng_shader_special.filter.rank}{$ [str]}
       Rank of the shader in the rendering sequence.
    @}*/
    SnkExtract.ExtractInt(m_Data->m_RankInfo, m_Data->m_Rank, "rank", true);
    
    /*@{ @declare{shadercomp.param}
            {eng_shader_special.filter.iter_start}{$ [int]}
        Iteration start value.
    @}*/
    m_Data->m_IterStart = SnkExtract.ExtractInt("iter_start", true);

    /*@{ @declare{shadercomp.param}
            {eng_shader_special.filter.iter_end}{$ [int]}
        Iteration end value.
    @}*/
    m_Data->m_IterEnd = SnkExtract.ExtractInt("iter_end", true);

    /*@{ @declare{shadercomp.param}
            {eng_shader_special.filter.iter_step}{$ [int]}
        Iteration step.
        If the step is positive, then the step is added to the start value 
        until the value is larger than the end.
        If the step is negative, then the step is added to the start value
        until the value is smaller than the end.
        If the step is zero, the iteration is only executed once
        for the start value.
    @}*/
    m_Data->m_IterStep = SnkExtract.ExtractInt("iter_step", true);

    /*@{ @declare{shadercomp.param}
            {eng_shader_special.filter.iter_width_scale}{$ [float]}
        Scale the image by this scale each iteration.
        The last iteration 
    @}*/
    m_Data->m_IterWidthScale = SnkExtract.ExtractFloat(
            "iter_width_scale", false);
    if(m_Data->m_IterWidthScale <= 0)
        m_Data->m_IterWidthScale = 1;

    /*@{ @declare{shadercomp.param}
            {eng_shader_special.filter.iter_height_scale}{$ [float]}
        Scale the image by this scale each iteration.
        The last iteration 
    @}*/
    m_Data->m_IterHeightScale 
            = SnkExtract.ExtractFloat("iter_height_scale", false);
    if(m_Data->m_IterHeightScale <= 0)
        m_Data->m_IterHeightScale = 1;

    m_Data->m_DestProp = 0;

    /*@{ @declare{shadercomp.param}
            {eng_shader_special.filter.destprop_antialias}{$ [bool]}
        Render the filtering with antialiasing.
    @}*/
    if(SnkExtract.ExtractBool("destprop_antialias", true))
        m_Data->m_DestProp |= s3d_CDrvGfxEng::DestProp_Antialias;

    /*@{ @declare{shadercomp.param}
            {eng_shader_special.filter.width_scale}{$ [float]}
       Requested final horizontal scaling factor.
    @}*/
    m_Data->m_WidthScale = SnkExtract.ExtractFloat("width_scale", false);
    if(m_Data->m_WidthScale <= 0)
        m_Data->m_WidthScale = 1;

    /*@{ @declare{shadercomp.param}
            {eng_shader_special.filter.height_scale}{$ [float]}
       Requested final vertical scaling factor.
    @}*/
    m_Data->m_HeightScale = SnkExtract.ExtractFloat("height_scale", false);
    if(m_Data->m_HeightScale <= 0)
        m_Data->m_HeightScale = 1;

    /*@{ @declare{shadercomp.param}
            {eng_shader_special.filter.passinfo_var}{$ [str]}
       This variable is a name for the float4-vector
       containing information about the iteration.
       The first component of the vector contains the current iteration number,
       The second the total number of iterations.
       The remaining components are unused.
    @}*/
    s3d_CUtilSnkExtractUtil::ExtractAtom(
            m_Data->m_TaskInfoVarInfo, m_Data->m_TaskInfoVarAtom,
            m_ShaderEnv->m_AtomMgr, SnkExtract, "passinfo_var", true);

    /*@{ @declare{shadercomp.param}
            {eng_shader_special.filter.shaderprog_ident}{$ [str]}
       Shader program used for the smoothing iterations.
    @}*/
    SnkExtract.ExtractStr(
            m_Data->m_ProgInfo, m_Data->m_ProgIdent, 
            "shaderprog_ident", true);

    /*@{ @declare{shadercomp.param}
            {eng_shader_special.filter.shaderprog_param_array}
            {$ [chunk] .. [chunk]}
       Defines which variables are passed to the shader program.
       See @ident{comp}{<shaderprog.map_prog_array>} for details.
    @}*/
    s3d_CUtilSnkChunkArray ProgParamChunkArray;
    SnkExtract.ExtractChunkArray(
            m_Data->m_ProgParamInfo, ProgParamChunkArray, 
            "shaderprog_param_array", true);
    
    /*@{ @declare{shadercomp.param}
            {eng_shader_special.filter.src_array}{$ [str]..[str]}
    @}*/
    s3d_CUtilSnkExtractUtil::ExtractAtomArray(
            m_Data->m_SrcVarInfo, m_Data->m_SrcVarAtomArray,
            m_ShaderEnv->m_AtomMgr, SnkExtract, "src_array", true);
    
    /*@{ @declare{shadercomp.param}
            {eng_shader_special.filter.dest_array}{$ [chunk]..[chunk]}
        See @ident{comp}{<dest_array>}.
    @}*/
    s3d_CUtilSnkChunkArray DestChunkArray;
    SnkExtract.ExtractChunkArray(DestChunkArray, "dest_array", true);

        m_Data->m_UpdateInterval = SnkExtract.ExtractInt("update_interval", true, 1);
        m_Data->m_StartFrame = SnkExtract.ExtractInt("start_frame", true, 0);
    m_Data->m_UpdateAllFace = SnkExtract.ExtractBool("update_all_face", true, true);
        m_Data->m_UsePoints = SnkExtract.ExtractBool("use_points", true, true);
        m_Data->m_PhotonCount = SnkExtract.ExtractInt("photon_count", true, 32*32);
        
    SnkExtract.CheckForUnknown();

    int ExtraTexProp = 0;
    int ExtraSampMode = 0;
    m_Data->m_Dest.Init(m_ShaderEnv, ExtraTexProp, 
            ExtraSampMode, DestChunkArray);

    s3d_CEngUtilGfxParamUtil::EvalMapProg(
            MsgHandler, m_Data->m_ProgParamInfo, 
            m_ShaderEnv->m_AtomMgr, ProgParamChunkArray,
            m_Data->m_ProgParamMapArray);
}

void gtp_Shader_CausticCube::SetupDone()
{
}

s3d_CUtilStr gtp_Shader_CausticCube::GetInfo()
{
    return m_Data->m_Info;
}

void gtp_Shader_CausticCube::RegisterNotif(s3d_CUtilNotifRecip *Recip)
{
}

s3d_CEngShaderGfxPtr gtp_Shader_CausticCube::FindShaderGfx(
        s3d_CUtilNotifGather *NotifGather, s3d_CEngGfxCtx *GfxCtx)
{
    if(!m_ShaderEnv)
        return 0;

    gtp_Shader_CausticCubeGfxPtr ShaderGfx;
    gtp_Shader_CausticCubeGfxTree::CNode *Pos
            = s3d_UtilTreeSortedGetStart(m_ShaderGfxTree, GfxCtx);
    if(s3d_UtilTreeIsEqualAt(Pos, GfxCtx))
        ShaderGfx = Pos->m_Data.m_Val;
    else
    {
        ShaderGfx = S3D_SYS_NEW gtp_Shader_CausticCubeGfx(
                m_ShaderEnv, NotifGather, GfxCtx, m_Data);
        gtp_Shader_CausticCubeGfxTree::CNode *Node
                = ShaderGfx->GetNode();
        m_ShaderGfxTree.InsertBefore(Pos, Node);
    }
    return ShaderGfx.Get();
}

///////////////////////////////////////////////////////////////////////////////

gtp_Shader_CausticCubeGfx::gtp_Shader_CausticCubeGfx(
        s3d_CEngShaderEnv *ShaderEnv, s3d_CUtilNotifGather *NotifGather,
        s3d_CEngGfxCtx *GfxCtx, 
        gtp_Shader_CausticCubeData *Data)
{
    m_Node.m_Data.m_Key = GfxCtx;
    m_Node.m_Data.m_Val = this;
    m_ShaderEnv = ShaderEnv;
    m_Data = Data;

    m_FilterDestGfx.Init(ShaderEnv, GfxCtx);

    s3d_CEngGfxProgMgr *GfxProgMgr = ShaderEnv->m_GfxProgMgr;
    if(GfxProgMgr)
        m_GfxProg = GfxProgMgr->CreateGfxProg(
                Data->m_ProgInfo, GfxCtx, NotifGather, 
                Data->m_ProgIdent);
}

gtp_Shader_CausticCubeGfxTree::CNode 
        *gtp_Shader_CausticCubeGfx::GetNode()
{
    return &m_Node;
}

void gtp_Shader_CausticCubeGfx::RegisterNotif(
        s3d_CUtilNotifRecip *Recip)
{
}

void gtp_Shader_CausticCubeGfx::ExtractGfx()
{
    m_Node.Extract();
}

bool gtp_Shader_CausticCubeGfx::IsValid()
{
    if(m_GfxProg && !m_GfxProg->IsValid())
        return false;
    return true;
}

void gtp_Shader_CausticCubeGfx::LinkCollect(
        s3d_CUtilAtomSet &VarAtomSet)
{
    s3d_CDrvUtilVarUtil::LinkCollect(
            VarAtomSet, m_Data->m_TaskInfoVarAtom);
    s3d_CDrvUtilVarUtil::LinkCollectArray(
            VarAtomSet, m_Data->m_SrcVarAtomArray);

    m_FilterDestGfx.LinkCollect(VarAtomSet, m_Data->m_Dest);

    s3d_CDrvUtilVarUtil::LinkCollectExport(
            VarAtomSet, m_Data->m_ProgParamMapArray);
}

void gtp_Shader_CausticCubeGfx::LinkAppoint(
        s3d_CDrvVarDecl *VarDecl)
{
    s3d_CDrvUtilVarUtil::LinkAppoint(
            m_TaskInfoVarSlot.m_Val, 
            VarDecl, m_Data->m_TaskInfoVarAtom);
    s3d_CDrvUtilVarUtil::LinkAppointArray(
            m_SrcVarSlotArray, 
            VarDecl, m_Data->m_SrcVarAtomArray);
    
    m_FilterDestGfx.LinkAppoint(VarDecl, m_Data->m_Dest);

    s3d_CDrvUtilVarUtil::LinkAppointExport(
            m_ShaderEnv->m_MsgHandler, m_Data->m_ProgParamInfo,
            m_ProgParamDecl, VarDecl,
            m_Data->m_ProgParamMapArray);
}

s3d_CEngShaderInstPtr gtp_Shader_CausticCubeGfx::CreateShaderInst(
        s3d_CEngShaderHead *Head)
{
    s3d_CEngGfxCtx *GfxCtx = m_Node.m_Data.m_Key;
    return S3D_SYS_NEW gtp_Shader_CausticCubeInst(
            m_ShaderEnv, GfxCtx, this, m_GfxProg);
}

///////////////////////////////////////////////////////////////////////////////

gtp_Shader_CausticCubeInst::gtp_Shader_CausticCubeInst(
        s3d_CEngShaderEnv *ShaderEnv,
        s3d_CEngGfxCtx *GfxCtx,
        gtp_Shader_CausticCubeGfx *ShaderGfx,
        s3d_CEngGfxProg *GfxProg)
{
    m_FrameCount = 0;
        m_ShaderEnv = ShaderEnv;
    m_GfxCtx = GfxCtx;
    m_ShaderGfx = ShaderGfx;
    m_GfxProg = GfxProg;
}

void gtp_Shader_CausticCubeInst::RegisterNotif(
        s3d_CUtilNotifRecip *Recip)
{
}

void gtp_Shader_CausticCubeInst::SetShaderCtx(
        s3d_CEngShaderCtx *ShaderCtx)
{
}

void gtp_Shader_CausticCubeInst::SetGfxState(
        s3d_CEngGfxState *GfxState)
{
}

void gtp_Shader_CausticCubeInst::SetPos(s3d_CEngPos *Pos)
{
}

void gtp_Shader_CausticCubeInst::SetModel(s3d_CEngModel *Model)
{
}

void gtp_Shader_CausticCubeInst::ArrangeCollect(
        s3d_CUtilMemPool *MemPool, 
        s3d_CEngShaderScopeArray &ScopeArray)
{
}

void gtp_Shader_CausticCubeInst::ArrangeInit(
        s3d_CUtilMemPool *MemPool, 
        s3d_CEngShaderScopeArray_cr ScopeArray)
{
}

void gtp_Shader_CausticCubeInst::ArrangePerform(
        s3d_CUtilMemPool *MemPool, 
        s3d_CEngShaderScopeArray_cr ScopeArray)
{
}

void gtp_Shader_CausticCubeInst::ArrangeFeedback(
        s3d_CUtilMemPool *MemPool, 
        s3d_CEngShaderScopeArray_cr ScopeArray)
{
}

void gtp_Shader_CausticCubeInst::ArrangeGather(
        s3d_CEngShaderExecArray &ExecArray)
{
    gtp_Shader_CausticCubeData *Data = m_ShaderGfx->m_Data;

    s3d_CEngUtilShaderUtil::ArrangeGather(
            ExecArray, Data->m_MethodArray, this);
}

void gtp_Shader_CausticCubeInst::ShaderExecPerform(
        s3d_CEngShaderScope *Scope, 
        s3d_CUtilAtom *Method,
        s3d_CEngGfxTaskArray &TaskArray)
{
    gtp_Shader_CausticCubeData *Data = m_ShaderGfx->m_Data;

        bool doRender = true;
        if(Data->m_UpdateInterval > 1)
        {
                if(m_FrameCount == Data->m_UpdateInterval)
                        m_FrameCount = 0;
                m_FrameCount++;
                if(!(m_FrameCount % Data->m_UpdateInterval == 1))       
                        doRender = false;
        }
        if(Data->m_UpdateInterval < 0)
                doRender = false;
        if(Data->m_UpdateInterval == 0)
        {
                Data->m_UpdateInterval = -1;
            Data->m_UpdateAllFace = true;
        }               

    int Rank = Data->m_Rank;
    if(Rank == 0)
        return;
        
        if(doRender)
        {
                s3d_CEngGfxElemJob *GfxElemJob = new(m_ShaderEnv->m_MemPool) 
                                s3d_CEngUtilShaderItemJob<gtp_Shader_CausticCubeInst>(
                                Scope, 0,
                                this, &gtp_Shader_CausticCubeInst::GfxElemJobExec);

                s3d_CEngGfxTaskOrder KeyOrder = 0;
                s3d_CEngUtilGfxUtil::AppendTask(
                                m_ShaderEnv->m_MemPool, TaskArray, Rank, KeyOrder, GfxElemJob);
        }
}

void *gtp_Shader_CausticCubeInst::GfxElemJobExec(
        s3d_CEngShaderScope *Scope,
        void *GfxMark)
{
    gtp_Shader_CausticCubeGfx *ShaderGfx = m_ShaderGfx;
    const gtp_Shader_CausticCubeData *Data = ShaderGfx->m_Data;

    s3d_CDrvGfxEng *GfxEng = m_GfxCtx->m_GfxEng;
    if(!GfxEng)
        return GfxMark;

    s3d_CEngUtilShaderDestGfx *FilterDestGfx = &ShaderGfx->m_FilterDestGfx;

    s3d_CEngGfxVarTexChanArray FilterSrcTexArray;
    FetchSrcArray(
            m_ShaderEnv->m_MemPool, Scope, Data->m_SrcVarInfo.GetChars(), 
            FilterSrcTexArray, ShaderGfx->m_SrcVarSlotArray);

    int RawBaseWidth = 0;
    int RawBaseHeight = 0;
    CalcSrcTexSize(
            m_ShaderEnv->m_MemPool, Scope, GfxEng, 
            RawBaseWidth, RawBaseHeight, FilterSrcTexArray);
    
    int DestProp = 0;
    if(!FilterDestGfx->GetSnapTexPropWidthHeight(
                m_ShaderEnv, Scope, Data->m_Dest, 
                RawBaseWidth, RawBaseHeight, DestProp))
        return GfxMark;

    float BaseWidth = RawBaseWidth * Data->m_WidthScale;
    float BaseHeight = RawBaseHeight * Data->m_HeightScale;
    if(BaseWidth <= 0)
        return GfxMark;
    if(BaseHeight <= 0)
        return GfxMark;

    int IterStart = Data->m_IterStart;
    int IterEnd = Data->m_IterEnd;
    int IterStep = Data->m_IterStep;
    if(IterStep > 0)
    {
        float CurWidth = BaseWidth;
        float CurHeight = BaseHeight;
        int Iter;
        for(Iter = IterStart; Iter <= IterEnd; Iter += IterStep)
        {
            CurWidth /= Data->m_IterWidthScale;
            CurHeight /= Data->m_IterHeightScale;
        }
        for(Iter = IterStart; Iter <= IterEnd; Iter += IterStep)
        {
            CurWidth *= Data->m_IterWidthScale;
            CurHeight *= Data->m_IterHeightScale;
            Iteration(Scope, Iter, DestProp, CurWidth, CurHeight);
        }
    }
    else if(IterStep < 0)
    {
        float CurWidth = BaseWidth;
        float CurHeight = BaseHeight;
        int Iter;
        for(Iter = IterStart; Iter >= IterEnd; Iter += IterStep)
        {
            CurWidth /= Data->m_IterWidthScale;
            CurHeight /= Data->m_IterHeightScale;
        }
        for(Iter = IterStart; Iter >= IterEnd; Iter += IterStep)
        {
            CurWidth *= Data->m_IterWidthScale;
            CurHeight *= Data->m_IterHeightScale;
            Iteration(Scope, Iter, DestProp, CurWidth, CurHeight);
        }
    }
    else
        Iteration(Scope, IterStart, 0/*DestProp*/, BaseWidth, BaseHeight);

    return 0;
}

void gtp_Shader_CausticCubeInst::Iteration(
        s3d_CEngShaderScope *Scope, int Iter,
        int DestProp, float WantWidth, float WantHeight)
{
    gtp_Shader_CausticCubeGfx *ShaderGfx = m_ShaderGfx;
    gtp_Shader_CausticCubeData *Data = ShaderGfx->m_Data;
    s3d_CEngUtilShaderDestGfx *FilterDestGfx = &ShaderGfx->m_FilterDestGfx;

    if(!Scope)
        return;

    s3d_CEngGfxPortion *Portion = Scope->m_Portion;
    if(!Portion)
        return;
    s3d_CEngGfxCycle *Cycle = Portion->m_Cycle;
    if(!Cycle)
        return;

    s3d_CUtilMemPool *MemPool = m_ShaderEnv->m_MemPool;

    s3d_CDrvVarVec4f *TaskInfoVar = new(MemPool) s3d_CDrvVarVec4f;
    TaskInfoVar->m_Val = 0;
    TaskInfoVar->m_Val.m_x = s3d_SysFloatOfInt<float>(Iter);
    s3d_DrvVarSet(Scope->m_VarBlk, ShaderGfx->m_TaskInfoVarSlot, TaskInfoVar);

    if(!s3d_CEngUtilGfxUtil::VerifyGfxClosed(
            m_ShaderEnv->m_MsgHandler, Data->m_RankInfo.GetChars(), 
            Portion->m_Cycle))
    {
        Data->m_Rank = 0; // Avoid the error being reported each frame
        return;
    }

    s3d_CDrvGfxEng *GfxEng = m_GfxCtx->m_GfxEng;
    if(!GfxEng)
        return;

    s3d_CEngGfxVarTexChanArray FilterSrcTexArray;
    FetchSrcArray(
            MemPool, Scope, Data->m_SrcVarInfo.GetChars(), 
            FilterSrcTexArray, ShaderGfx->m_SrcVarSlotArray);

    int DestWidth = s3d_SysIntOfFloatNearest(WantWidth);
    int DestHeight = s3d_SysIntOfFloatNearest(WantHeight);
    int DestDepth = 1;
    int DestSnap = s3d_CDrvGfxEng::TexSnap_PreferUp;
    GfxEng->SnapTexSize(DestWidth, DestHeight, DestDepth, DestProp, DestSnap);

    s3d_CEngUtilShaderDestJob *DestJob = FilterDestGfx->CreateJob(
                m_ShaderEnv, Scope, Data->m_Dest, DestWidth, DestHeight);
    if(!DestJob)
        return;

    s3d_CSysIntps nSrcTex = FilterSrcTexArray.GetCnt();
    int nSamp = GfxEng->GetSampCnt();
    
    if(nSrcTex > nSamp)
    {
        s3d_CUtilMsg e;
        e.m_Code = "eng/shader/eng_shader_special_filter.too_many_tex";
        e.m_StdTempl = "Too many textures specified. "
                       "Max textures allowed '[1]'.";
        e.AddInfo(Data->m_Info);
        e.AddInfo(s3d_CUtilStrUtil::StrOfInt(nSamp));
        s3d_UtilMsgReportError(m_ShaderEnv->m_MsgHandler, e);
        return;
    }

    // Filter:

    GfxEng->SetPaintMode(s3d_CDrvGfxEng::PaintMode_Fill);
    GfxEng->SetCullMode(s3d_CDrvGfxEng::CullMode_None);
    GfxEng->SetDepthTest(s3d_CDrvGfxEng::TestMode_Always);
    GfxEng->SetDepthWrite(false);
    GfxEng->SetDepthBias(0, 0);
    GfxEng->SetStencilMode(
            0, 
            0, 
            s3d_CDrvGfxEng::TestMode_Always, 
            s3d_CDrvGfxEng::TestMode_Always, 
            0,
            s3d_CDrvGfxEng::StencilOp_Keep, 
            s3d_CDrvGfxEng::StencilOp_Keep, 
            s3d_CDrvGfxEng::StencilOp_Keep,
            s3d_CDrvGfxEng::StencilOp_Keep, 
            s3d_CDrvGfxEng::StencilOp_Keep, 
            s3d_CDrvGfxEng::StencilOp_Keep);
    GfxEng->SetFogNone();
    
    GfxEng->SetAlphaTest(s3d_CDrvGfxEng::TestMode_Always, 0);
    GfxEng->DisableLighting();
    GfxEng->SetColorAlpha(0);

    GfxEng->SetSampTexElseNone(int(nSrcTex));

    s3d_CDrvGfxProg *DrvProg = 0;
    if(m_GfxProg)
        DrvProg = m_GfxProg->GetDrvProg();

    s3d_CDrvGfxParam GfxParam;
    GfxParam.m_Blk.m_Decl = ShaderGfx->m_ProgParamDecl;
    GfxParam.m_Blk.m_Data = Scope->m_VarBlk.m_Data;

    s3d_CUtilMemPoolFrm MemPoolFrm(MemPool);
    s3d_CDrvUtilPaintTri PaintTri(
            Data->m_Info.GetChars(), MemPool, GfxEng, DrvProg);

    s3d_CDrvGfxClearParam ClearParam;
    s3d_CDrvGfxDest *Dest = DestJob->m_DrvGfxDestArray.GetPtrRaw();
    s3d_CSysIntps nDestTex = DestJob->m_DrvGfxDestArray.GetCnt();
    
        

        static const int CubeFaceMap[] =
    {
        s3d_CDrvGfxEng::TexPart_CubeNegX, s3d_CDrvGfxEng::TexPart_CubePosX, 
        s3d_CDrvGfxEng::TexPart_CubeNegY, s3d_CDrvGfxEng::TexPart_CubePosY,   
        s3d_CDrvGfxEng::TexPart_CubePosZ, s3d_CDrvGfxEng::TexPart_CubeNegZ, 
    };
        static const s3d_CUtilVec3f ViewDirMap[] = 
    {
        s3d_CUtilVec3f( 1.f, 0.f, 0.f), s3d_CUtilVec3f(-1.f,  0.f,  0.f), 
        s3d_CUtilVec3f( 0.f, 1.f, 0.f), s3d_CUtilVec3f( 0.f, -1.f,  0.f), 
        s3d_CUtilVec3f( 0.f, 0.f, 1.f), s3d_CUtilVec3f( 0.f,  0.f, -1.f),  
    };
    static const s3d_CUtilVec3f AlsoFromMap[] = 
    {
        s3d_CUtilVec3f( 1.f, 0.f, 0.f), s3d_CUtilVec3f( 1.f,  0.f, 0.f), 
        s3d_CUtilVec3f( 0.f, 1.f, 0.f), s3d_CUtilVec3f( 0.f,  1.f, 0.f), 
        s3d_CUtilVec3f( 1.f, 0.f, 0.f), s3d_CUtilVec3f( 1.f,  0.f, 0.f), 
    };
    static const s3d_CUtilVec3f AlsoToMap[] = 
    {
        s3d_CUtilVec3f( 0.f,  0.f, -1.f), s3d_CUtilVec3f(  0.f, 0.f, 1.f),  
        s3d_CUtilVec3f( 0.f,  0.f, -1.f), s3d_CUtilVec3f(  0.f, 0.f, 1.f),  
        s3d_CUtilVec3f( 1.f,  0.f,  0.f), s3d_CUtilVec3f( -1.f, 0.f, 0.f), 
    };
    
        GfxEng->SetTransfIdentity(s3d_CDrvGfxEng::TransfChan_Proj, 0);
    GfxEng->SetTransfIdentity(s3d_CDrvGfxEng::TransfChan_View, 0);
    
        const s3d_CUtilVec3f CamDir(0, 0, 1);
        s3d_CUtilMat4x4f projMat = s3d_CEngUtilMathUtil::CalcProjStd(
            false, 1, -1, 0, 0, 0.1, 5.0);      
        GfxEng->SetTransf(s3d_CDrvGfxEng::TransfChan_Proj, 0, projMat);

    s3d_CUtilTranslQuatf ViewTransf;
        ViewTransf.m_Transl = s3d_CUtilVec3f(0,0,0);

        s3d_CUtilMat4x4f viewMat;

        int steps = 1;
        if(Data->m_UsePoints)
        {
                steps = 2;
                GfxEng->SetPaintMode(s3d_CDrvGfxEng::PaintMode_Point);
        }        
        float pixelSize = 1.0f / (float) Data->m_PhotonCount;
        float halfPixelSize = 0.5f * pixelSize;
     
        
        ClearParam.m_MustColorAlpha = true;
        ClearParam.m_MustDepth = false;
        ClearParam.m_Depth = 1.0;
        ClearParam.m_ColorAlpha = s3d_CUtilVec4f(0.0,0.0,0.0,1.0);

        for(int iFace = 0; iFace < 6; iFace++)  
        {
                if(!Data->m_UpdateAllFace)
                {
                        iFace = m_CurrentFace;
                        m_CurrentFace = (++m_CurrentFace) % 6;
                }
      
         for(int i = 0; i < Data->m_PhotonCount - 1; i += steps)
                        for(int j = 0; j < Data->m_PhotonCount - 1; j += steps)
                        {
                          float X1 = i * pixelSize + halfPixelSize; 
                          float Y1 = j * pixelSize + halfPixelSize; 
                          float X2 = (i + 1) * pixelSize + halfPixelSize; 
                          float Y2 = (j + 1) * pixelSize + halfPixelSize; 
                        
                          PaintTri.AddQuadAligned(
                                s3d_CUtilVec2f(X1, Y1), 
                                s3d_CUtilVec2f(0, 0), 
                                s3d_CUtilVec2f(X2, Y2), 
                                s3d_CUtilVec2f(1, 1), 
                                0, s3d_CUtilVec4f(0,0,0,0));
                        }

                s3d_CUtilQuatf EffQuat = s3d_CUtilQuatf::ByPathAlso(
                CamDir, ViewDirMap[iFace], AlsoFromMap[iFace], 
                        AlsoToMap[iFace]);
                ViewTransf.m_Quat = EffQuat;
                viewMat = s3d_CUtilGeof::GetMapOfTransf3(ViewTransf);
                GfxEng->SetTransf(s3d_CDrvGfxEng::TransfChan_View, 0, viewMat);
        
                for(int j = 0; j < nDestTex; j++)
                  Dest[j].m_Part = CubeFaceMap[iFace];        
                
                GfxEng->BeginRenderTex(Data->m_DestProp, ClearParam,
                                DestWidth, DestHeight, nDestTex, Dest);

                GfxEng->SetBlendMode(
             s3d_CDrvGfxEng::BlendFac_SrcAlpha, 
            s3d_CDrvGfxEng::BlendFac_One,
            s3d_CDrvGfxEng::BlendOp_SrcPlusDest,
            s3d_CDrvGfxEng::BlendFac_One, 
            s3d_CDrvGfxEng::BlendFac_One,
            s3d_CDrvGfxEng::BlendOp_SrcPlusDest);

                GfxEng->SetViewRect(1);
    
                int iSamp;
                for(iSamp = 0; iSamp < nSrcTex; iSamp++)
                {
                        const s3d_CEngGfxVarTexChan *SrcTexChanVar = 
                                        FilterSrcTexArray[iSamp];
                        s3d_CDrvGfxTex *DrvTex = 0;
                        if(SrcTexChanVar)
                                DrvTex = SrcTexChanVar->m_Val.m_FixedDrvTex;
                        GfxEng->SetSampTex(iSamp, DrvTex);
                        GfxEng->SetSampMode(iSamp, SrcTexChanVar->m_Val.m_FixedSampMode);
                }               

                PaintTri.Perform(GfxParam);

                GfxEng->EndRender();            
        }

    FilterDestGfx->FinishJob(
            m_ShaderEnv, Scope, Data->m_Dest, DestJob);
}

void gtp_Shader_CausticCubeInst::FetchSrcArray(
        s3d_CUtilMemPool *MemPool, s3d_CEngShaderScope *Scope, 
        const s3d_CSysChar *Info,
        s3d_CEngGfxVarTexChanArray &SrcTexArray,
        s3d_CDrvVarSlotArray &SrcVarSlotArray)
{
    s3d_CSysIntps nTex = SrcVarSlotArray.GetCnt();
    SrcTexArray.SetCnt(MemPool, nTex);
    s3d_CSysIntps iTex;
    for(iTex = 0; iTex < nTex; iTex++)
    {
        s3d_CEngGfxVarTexChan *TexChanVar = 
                s3d_EngGfxVarFetchWaryTexChan(
                    m_ShaderEnv->m_MsgHandler, Info, Scope->m_VarBlk, 
                    SrcVarSlotArray.RefAt(iTex));        
        SrcTexArray.SetAt(iTex, TexChanVar);
    }
}

void gtp_Shader_CausticCubeInst::CalcSrcTexSize(
        s3d_CUtilMemPool *MemPool, s3d_CEngShaderScope *Scope,
        s3d_CDrvGfxEng *GfxEng, int &Width, int &Height, 
        s3d_CEngGfxVarTexChanArray &FilterSrcTexArray)
{
    Width = 0;
    Height = 0;

    s3d_CSysIntps nSrcTex = FilterSrcTexArray.GetCnt();
    s3d_CSysIntps iSrcTex;
    for(iSrcTex = 0; iSrcTex < nSrcTex; iSrcTex++)
    {
        s3d_CEngGfxVarTexChan *SrcTexChan = FilterSrcTexArray[iSrcTex];
        if(!SrcTexChan)
            continue;
        s3d_CDrvGfxTex *SrcDrvTex = SrcTexChan->m_Val.m_FixedDrvTex;
        if(!SrcDrvTex)
            continue;

        int SrcTexWidth, SrcTexHeight, SrcTexDepth;
        SrcDrvTex->GetSize(SrcTexWidth, SrcTexHeight, SrcTexDepth);

        if(Width < SrcTexWidth)
            Width = SrcTexWidth;
        if(Height < SrcTexHeight)
            Height = SrcTexHeight;
    }
}

///////////////////////////////////////////////////////////////////////////////