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

//@cpp

#include "gtp_shader_mainenum.h"
#include "../../util/eng_util_gfxutil.h"
#include "../../util/eng_util_shaderutil.h"
#include "../../util/eng_util_mathutil.h"
#include "../../../drv/interf/drv_vartypes.h"
#include "../../../drv/util/drv_util_varutil.h"
#include "../../../util/snk/util_snk_extractutil.h"
#include "../../../util/math/util_geo_types.h"

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

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

Provides a matrix which maps from view coordinates
in world coordinates.
@p

Important warning!
Usually, if you need this matrix something is wrong!
See @ref{prog_man.shader.coord_systems}.
@p

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

S3D_UTIL_RTTI_TABLE_DEFINE_BEGIN(gtp_Shader_MainEnum)
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_MainEnum::gtp_Shader_MainEnum()
{
}

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

    s3d_CUtilSnkExtract SnkExtract;
    SnkExtract.Assign(MsgHandler, Param);
    m_Data->m_Info = SnkExtract.GetInfo();

    /*@{ @declare{shadercomp.param}{eng_shader_special.worldmat.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.worldmat.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.worldmat.worldmat_var}{$ [str]}
        The variable stores the resulting matrix.
        The variable is of type mat4x4f. 
    @}*/
    s3d_CUtilSnkExtractUtil::ExtractAtom(
            m_Data->m_MainEnumVarInfo, m_Data->m_MainEnumVarAtom,
            m_ShaderEnv->m_AtomMgr, SnkExtract, "coll_var", true);	

    SnkExtract.CheckForUnknown();
}

void gtp_Shader_MainEnum::SetupDone()
{
}

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

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

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

    gtp_Shader_MainEnumGfxPtr ShaderGfx;

    gtp_Shader_MainEnumGfxTree::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_MainEnumGfx(
                m_ShaderEnv, GfxCtx, m_Data);
        gtp_Shader_MainEnumGfxTree::CNode *Node
                = ShaderGfx->GetNode();
        m_ShaderGfxTree.InsertBefore(Pos, Node);
    }
    return ShaderGfx.Get();
}

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

gtp_Shader_MainEnumGfx::gtp_Shader_MainEnumGfx(
        s3d_CEngShaderEnv *ShaderEnv, s3d_CEngGfxCtx *GfxCtx,
        gtp_Shader_MainEnumData *Data)
{
    m_Node.m_Data.m_Key = GfxCtx;
    m_Node.m_Data.m_Val = this;
    m_ShaderEnv = ShaderEnv;
    m_Data = Data;
}

gtp_Shader_MainEnumGfxTree::CNode *
        gtp_Shader_MainEnumGfx::GetNode()
{
    return &m_Node;
}

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

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

bool gtp_Shader_MainEnumGfx::IsValid()
{
    return true;
}

void gtp_Shader_MainEnumGfx::LinkCollect(
        s3d_CUtilAtomSet &VarAtomSet)
{
    s3d_CDrvUtilVarUtil::LinkCollect(
            VarAtomSet, m_Data->m_MainEnumVarAtom);
}

void gtp_Shader_MainEnumGfx::LinkAppoint(
        s3d_CDrvVarDecl *VarDecl)
{
    s3d_CDrvUtilVarUtil::LinkAppoint(
            m_MainEnumVarSlot.m_Val, 
            VarDecl, m_Data->m_MainEnumVarAtom);
}

s3d_CEngShaderInstPtr gtp_Shader_MainEnumGfx::CreateShaderInst(
        s3d_CEngShaderHead *Head)
{
    return S3D_SYS_NEW gtp_Shader_MainEnumInst(
            m_ShaderEnv, this);
}

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

gtp_Shader_MainEnumInst::gtp_Shader_MainEnumInst(
        s3d_CEngShaderEnv *ShaderEnv, 
        gtp_Shader_MainEnumGfx *ShaderGfx)
{
    m_ShaderEnv = ShaderEnv;
    m_ShaderGfx = ShaderGfx;
}

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

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

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

void gtp_Shader_MainEnumInst::SetPos(s3d_CEngPos *Pos)
{
    m_Pos = Pos;
}

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

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

void gtp_Shader_MainEnumInst::ArrangeInit(
        s3d_CUtilMemPool *MemPool, 
        s3d_CEngShaderScopeArray_cr ScopeArray)
{
    s3d_CSysIntps nScope = ScopeArray.GetCnt();
    s3d_CSysIntps iScope;
    for(iScope = 0; iScope < nScope; iScope++)
    {
        s3d_CEngShaderScope *Scope = ScopeArray.GetAt(iScope);
        SetVars(MemPool, Scope);
    }
}

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

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

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

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

void gtp_Shader_MainEnumInst::ShaderExecPerform(
        s3d_CEngShaderScope *Scope, 
        s3d_CUtilAtom *Method,
        s3d_CEngGfxTaskArray &TaskArray)
{
    SetVars(m_ShaderEnv->m_MemPool, Scope);
}

void gtp_Shader_MainEnumInst::SetVars(
        s3d_CUtilMemPool *MemPool, s3d_CEngShaderScope *Scope)
{
    gtp_Shader_MainEnumGfx *ShaderGfx = m_ShaderGfx;
    gtp_Shader_MainEnumData *Data = ShaderGfx->m_Data;

    s3d_CDrvVarSlot MainEnumVarSlot = ShaderGfx->m_MainEnumVarSlot;
    if(MainEnumVarSlot >= 0)
    {
        s3d_CEngGfxPortion *Portion = Scope->m_Portion;
		if(Portion)
		{
			s3d_CEngGfxVarColl *MainEnumVar = new(MemPool) s3d_CEngGfxVarColl;
			MainEnumVar->m_Val.m_GfxElemArray.Reset();
			int size = Portion->m_VisibleGfxElemArrayMain.GetCntInt();
			for(int i = 0; i< size ; i++)
               MainEnumVar->m_Val.m_GfxElemArray.InsertBack(
					MemPool,Portion->m_VisibleGfxElemArrayMain[i]);
			s3d_DrvVarSet(Scope->m_VarBlk, MainEnumVarSlot, MainEnumVar);
		}
    }
}

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