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

//@cpp

#include "gtp_shader_createtex.h"
#include "../../interf/eng_gfxvar.h"
#include "../../util/eng_util_gfxutil.h"
#include "../../util/eng_util_shaderutil.h"
#include "../../../drv/interf/drv_vartypes.h"
#include "../../../drv/util/drv_util_varutil.h"
#include "../../../util/snk/util_snk_extractutil.h"

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

@declare{shadercomp.class}{eng_shader_std.directtexchan}{}

This component writes a reference to a texture 
into a texture channel variable.
See also @ref{prog_man.shader.texture_channels}.
@p

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

S3D_UTIL_RTTI_TABLE_DEFINE_BEGIN(gtp_ShaderCreateTex)
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_ShaderCreateTex::gtp_ShaderCreateTex()
{
}

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

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

    /*@{ @declare{shadercomp.param}{eng_shader_std.directtexchan.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_std.directtexchan.methods}
            {$ [str] .. [str]}
        See @ref{prog_man.shader.methods}.
    @}*/
    s3d_CUtilSnkExtractUtil::ExtractAtomSortedArray(
            m_Data->m_MethodArray, m_ShaderEnv->m_AtomMgr, 
            SnkExtract, "methods", true);


	///Texture properties
	int TexWidth = 256, TexHeight = 256, TexDepth = 1, TexCompCnt = 3, TexBitPComp = 8;
	
	int TexProp = 0;
    if(SnkExtract.ExtractBool("texprop_rendertarget", true))
		TexProp |= s3d_CDrvGfxEng::TexProp_RenderTarget;
	if(SnkExtract.ExtractBool("texprop_cube", true))
		TexProp |= s3d_CDrvGfxEng::TexProp_Cube;
	if(SnkExtract.ExtractBool("texprop_volume", true))
		TexProp |= s3d_CDrvGfxEng::TexProp_Volume;
	if(SnkExtract.ExtractBool("texprop_mipmap", true))
		TexProp |= s3d_CDrvGfxEng::TexProp_Mipmap;
	if(SnkExtract.ExtractBool("texprop_float", true))
		TexProp |= s3d_CDrvGfxEng::TexProp_Float;
	if(SnkExtract.ExtractBool("texprop_signed", true))
		TexProp |= s3d_CDrvGfxEng::TexProp_Signed;
	if(SnkExtract.ExtractBool("texprop_restrusage", true))
		TexProp |= s3d_CDrvGfxEng::TexProp_RestrUsage;
	if(SnkExtract.ExtractBool("texprop_compressed", true))
		TexProp |= s3d_CDrvGfxEng::TexProp_Compress;
	if(SnkExtract.ExtractBool("texprop_dynamic", true))
		TexProp |= s3d_CDrvGfxEng::TexProp_Dynamic;
	if(SnkExtract.ExtractBool("texprop_alpha_mask", true))
		TexProp |= s3d_CDrvGfxEng::TexProp_AlphaIsMask;

	TexCompCnt = SnkExtract.ExtractInt("texprop_comp", true, TexCompCnt);
	TexBitPComp = SnkExtract.ExtractInt("texprop_bitspercomp", true, TexBitPComp);

	switch(TexCompCnt)
	{
		case 1:
			TexProp |= s3d_CDrvGfxEng::TexProp_Comp1;
			break;
		case 2:
			TexProp |= s3d_CDrvGfxEng::TexProp_Comp2;
			break;
		case 4:
			TexProp |= s3d_CDrvGfxEng::TexProp_Comp4;
			break;
		default:
			TexProp |= s3d_CDrvGfxEng::TexProp_Comp3;
	}

	switch(TexBitPComp)
	{
		case 16:
			TexProp |= s3d_CDrvGfxEng::TexProp_BitsPerComp16;
			break;
		case 32:
			TexProp |= s3d_CDrvGfxEng::TexProp_BitsPerComp32;
			break;
		default:
			TexProp |= s3d_CDrvGfxEng::TexProp_BitsPerComp8;
	}
	
	TexWidth = SnkExtract.ExtractInt("width", true, TexWidth);
	TexHeight = SnkExtract.ExtractInt("height", true, TexHeight);
	TexDepth = SnkExtract.ExtractInt("depth", true, TexDepth);
	
	
	m_Data->m_TexProp = TexProp;
	m_Data->m_TexWidth = TexWidth;
	m_Data->m_TexHeight = TexHeight;
	m_Data->m_TexDepth = TexDepth;

   
		
   /* s3d_CCompSetup::SetupInitObj(
            m_ShaderEnv->m_MsgHandler, Info, Tex, FetchSuppl, TexParam);
    m_Data->m_Tex = Tex;*/

    /*@{ @declare{shadercomp.param}{eng_shader_std.directtexchan.texchan_var}
            {$ [str]}
       Variable where texture is being stored in for use by shader components 
       within this group.
    @}*/
    s3d_CUtilAtomPtr TexChanVarAtom;
    s3d_CUtilStr TexChanInfo;
    s3d_CUtilSnkExtractUtil::ExtractAtom(
            m_Data->m_TexChanVarInfo, m_Data->m_TexChanVarAtom,
            m_ShaderEnv->m_AtomMgr, SnkExtract, "texchan_var", true);

    m_Data->m_SampMode = 0;

    /*@{ @declare{shadercomp.param}
            {eng_shader_std.directtexchan.samplermode_clamp}
            {$ [bool]}
    @}*/
    if(SnkExtract.ExtractBool("samplermode_clamp", true))
    {
        m_Data->m_SampMode |= s3d_CDrvGfxEng::SampMode_ClampX;
        m_Data->m_SampMode |= s3d_CDrvGfxEng::SampMode_ClampY;
    }

    /*@{ @declare{shadercomp.param}
            {eng_shader_std.directtexchan.samplermode_filter}
            {$ [bool]}
    @}*/
    if(SnkExtract.ExtractBool("samplermode_filter", true))
        m_Data->m_SampMode |= s3d_CDrvGfxEng::SampMode_Filter;

    SnkExtract.CheckForUnknown();
}

void gtp_ShaderCreateTex::SetupDone()
{
}

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

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

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

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

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

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

	
}

gtp_ShaderCreateTexGfxTree::CNode 
        *gtp_ShaderCreateTexGfx::GetNode()
{
    return &m_Node;
}

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

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

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

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

void gtp_ShaderCreateTexGfx::LinkAppoint(
        s3d_CDrvVarDecl *VarDecl)
{
    s3d_CDrvUtilVarUtil::LinkAppoint(
            m_TexChanVarSlot.m_Val,
            VarDecl, m_Data->m_TexChanVarAtom);   
}

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

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

gtp_ShaderCreateTexInst::gtp_ShaderCreateTexInst(
        s3d_CEngShaderEnv *ShaderEnv,
        gtp_ShaderCreateTexGfx *ShaderGfx)
{
    m_ShaderEnv = ShaderEnv;
    m_ShaderGfx = ShaderGfx;

	 s3d_CDrvGfxTexPtr Tex = 
		 m_ShaderGfx->m_Node.m_Data.m_Key->m_GfxEng->
				   CreateTexDirect( m_ShaderGfx->m_Data->m_Info, 
									m_ShaderGfx->m_Data->m_TexProp,
									m_ShaderGfx->m_Data->m_TexWidth,
									m_ShaderGfx->m_Data->m_TexHeight,
									m_ShaderGfx->m_Data->m_TexDepth);

	 m_TexGfx = m_ShaderGfx->m_Data->m_Tex = Tex;
}

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

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

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

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

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

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

void gtp_ShaderCreateTexInst::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_ShaderCreateTexInst::ArrangePerform(
        s3d_CUtilMemPool *MemPool, 
        s3d_CEngShaderScopeArray_cr ScopeArray)
{
}

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

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

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

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

void gtp_ShaderCreateTexInst::SetVars(
        s3d_CUtilMemPool *MemPool, s3d_CEngShaderScope *Scope)
{
    gtp_ShaderCreateTexGfx *ShaderGfx = m_ShaderGfx;
    gtp_ShaderCreateTexData *Data = ShaderGfx->m_Data;

    s3d_CDrvVarSlot TexChanVarSlot = ShaderGfx->m_TexChanVarSlot;
    if(TexChanVarSlot >= 0)
    {
        s3d_CEngGfxVarTexChan *TexChanVar = 
                new(MemPool) s3d_CEngGfxVarTexChan;

        s3d_CEngTexChan *TexChan = &TexChanVar->m_Val;
        TexChan->m_FixedDrvTex = 0;
        s3d_CDrvGfxTexPtr TexGfx = m_TexGfx;
        if(TexGfx)
            TexChan->m_FixedDrvTex = TexGfx;
        TexChan->m_FixedSampMode = Data->m_SampMode;

        s3d_DrvVarSet(Scope->m_VarBlk, TexChanVarSlot, TexChanVar);
    }
}

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