You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

259 lines
8.4 KiB

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#include "plGrassShaderMod.h"
#include "hsTimer.h"
#include "hsResMgr.h"
#include "plgDispatch.h"
#include "pnKeyedObject/plUoid.h"
//#include "pnSceneObject/plDrawInterface.h"
#include "pnMessage/plObjRefMsg.h"
#include "pnMessage/plTimeMsg.h"
#include "plMessage/plMatRefMsg.h"
#include "plMessage/plAgeLoadedMsg.h"
#include "plMessage/plLayRefMsg.h"
#include "plDrawable/plAccessGeometry.h"
#include "plDrawable/plAccessSpan.h"
#include "plDrawable/plAccessVtxSpan.h"
#include "plSurface/hsGMaterial.h"
#include "plSurface/plShader.h"
#include "plSurface/plLayer.h"
void plGrassWave::Write(hsStream *s)
{
s->WriteSwapScalar(fDistX);
s->WriteSwapScalar(fDistY);
s->WriteSwapScalar(fDistZ);
s->WriteSwapScalar(fDirX);
s->WriteSwapScalar(fDirY);
s->WriteSwapScalar(fSpeed);
}
void plGrassWave::Read(hsStream *s)
{
fDistX = s->ReadSwapScalar();
fDistY = s->ReadSwapScalar();
fDistZ = s->ReadSwapScalar();
fDirX = s->ReadSwapScalar();
fDirY = s->ReadSwapScalar();
fSpeed = s->ReadSwapScalar();
}
/////////////////////////////////////////////////////////////////////////////////////////////
plGrassShaderMod::~plGrassShaderMod()
{
plgDispatch::Dispatch()->UnRegisterForExactType(plEvalMsg::Index(), GetKey());
plgDispatch::Dispatch()->UnRegisterForExactType(plInitialAgeStateLoadedMsg::Index(), GetKey());
plgDispatch::Dispatch()->UnRegisterForExactType(plAgeLoadedMsg::Index(), GetKey());
}
void plGrassShaderMod::ResetWaves()
{
int i;
for (i = 0; i < kNumWaves; i++)
{
fWaves[i].fDistX = 0.F;
fWaves[i].fDistY = 0.F;
fWaves[i].fDistZ = 0.F;
fWaves[i].fDirX = 0.F;
fWaves[i].fDirY = 0.F;
fWaves[i].fSpeed = 0.F;
}
RefreshWaves();
}
void plGrassShaderMod::RefreshWaves()
{
IRefreshWaves(fVShader);
}
void plGrassShaderMod::IRefreshWaves(plShader *vShader)
{
// Dynamic params, set by artist
vShader->SetVector(plGrassVS::kWaveDistX, fWaves[0].fDistX, fWaves[1].fDistX, fWaves[2].fDistX, fWaves[3].fDistX);
vShader->SetVector(plGrassVS::kWaveDistY, fWaves[0].fDistY, fWaves[1].fDistY, fWaves[2].fDistY, fWaves[3].fDistY);
vShader->SetVector(plGrassVS::kWaveDistZ, fWaves[0].fDistZ, fWaves[1].fDistZ, fWaves[2].fDistZ, fWaves[3].fDistZ);
vShader->SetVector(plGrassVS::kWaveDirX, fWaves[0].fDirX, fWaves[1].fDirX, fWaves[2].fDirX, fWaves[3].fDirX);
vShader->SetVector(plGrassVS::kWaveDirY, fWaves[0].fDirY, fWaves[1].fDirY, fWaves[2].fDirY, fWaves[3].fDirY);
vShader->SetVector(plGrassVS::kWaveSpeed, fWaves[0].fSpeed, fWaves[1].fSpeed, fWaves[2].fSpeed, fWaves[3].fSpeed);
}
void plGrassShaderMod::AddTarget(plSceneObject *object)
{
fTarget = object;
}
void plGrassShaderMod::RemoveTarget(plSceneObject *object)
{
fTarget = nil;
}
hsBool plGrassShaderMod::MsgReceive(plMessage *msg)
{
plGenRefMsg* refMsg = plGenRefMsg::ConvertNoRef(msg);
if (refMsg)
{
if (refMsg->GetContext() & (plRefMsg::kOnCreate | plRefMsg::kOnRequest | plRefMsg::kOnReplace))
{
switch (refMsg->fType)
{
case kRefGrassVS:
fVShader = plShader::ConvertNoRef(refMsg->GetRef());
break;
case kRefGrassPS:
fPShader = plShader::ConvertNoRef(refMsg->GetRef());
break;
case kRefMaterial:
fMaterial = hsGMaterial::ConvertNoRef(refMsg->GetRef());
break;
default:
break;
}
}
else
{
switch (refMsg->fType)
{
case kRefGrassVS:
fVShader = nil;
break;
case kRefGrassPS:
fPShader = nil;
break;
case kRefMaterial:
fMaterial = nil;
break;
default:
break;
}
}
return true;
}
plAgeLoadedMsg* ageLoaded = plAgeLoadedMsg::ConvertNoRef(msg);
if( (ageLoaded && ageLoaded->fLoaded) || plInitialAgeStateLoadedMsg::ConvertNoRef(msg) )
{
ISetupShaders();
return true;
}
return plModifier::MsgReceive(msg);
}
void plGrassShaderMod::Write(hsStream *stream, hsResMgr *mgr)
{
plModifier::Write(stream, mgr);
mgr->WriteKey(stream, fMaterial ? fMaterial->GetKey() : nil);
int i;
for (i = 0; i < kNumWaves; i++)
fWaves[i].Write(stream);
}
void plGrassShaderMod::Read(hsStream *stream, hsResMgr *mgr)
{
plModifier::Read(stream, mgr);
mgr->ReadKeyNotifyMe(stream, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnRequest, 0, kRefMaterial), plRefFlags::kActiveRef);
int i;
for (i = 0; i < kNumWaves; i++)
fWaves[i].Read(stream);
plgDispatch::Dispatch()->RegisterForExactType(plEvalMsg::Index(), GetKey());
plgDispatch::Dispatch()->RegisterForExactType(plInitialAgeStateLoadedMsg::Index(), GetKey());
plgDispatch::Dispatch()->RegisterForExactType(plAgeLoadedMsg::Index(), GetKey());
}
hsBool plGrassShaderMod::IEval(double secs, hsScalar del, UInt32 dirty)
{
if (fVShader)
{
fVShader->SetVector(plGrassVS::kAppConsts, float(hsTimer::GetSysSeconds()), 0.f, 0.f, 0.f);
}
return TRUE;
}
void plGrassShaderMod::ISetupShaders()
{
if (!fVShader)
{
plShader* vShader = TRACKED_NEW plShader;
char buff[256];
sprintf(buff, "%s_GrassVS", GetKey()->GetName());
hsgResMgr::ResMgr()->NewKey(buff, vShader, GetKey()->GetUoid().GetLocation());
vShader->SetIsPixelShader(false);
vShader->SetInputFormat(1);
vShader->SetOutputFormat(0);
vShader->SetNumConsts(plGrassVS::kNumConsts);
vShader->SetVector(plGrassVS::kNumericConsts, 0.f, 0.5f, 1.f, 2.f);
vShader->SetVector(plGrassVS::kPiConsts, 1.f / (8.f*hsScalarPI*4.f*4.f), hsScalarPI/2.f, hsScalarPI, hsScalarPI*2.f);
vShader->SetVector(plGrassVS::kSinConsts, -1.f/6.f, 1.f/120.f, -1.f/5040.f, 1.f/362880.f);
IRefreshWaves(vShader);
vShader->SetNumPipeConsts(1);
vShader->SetPipeConst(0, plPipeConst::kLocalToNDC, plGrassVS::kLocalToNDC);
vShader->SetDecl(plShaderTable::Decl(plShaderID::vs_GrassShader));
hsgResMgr::ResMgr()->SendRef(vShader->GetKey(), TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnRequest, 0, kRefGrassVS), plRefFlags::kActiveRef);
}
if (!fPShader)
{
plShader* pShader = TRACKED_NEW plShader;
char buff[256];
sprintf(buff, "%s_GrassPS", GetKey()->GetName());
hsgResMgr::ResMgr()->NewKey(buff, pShader, GetKey()->GetUoid().GetLocation());
pShader->SetIsPixelShader(true);
pShader->SetNumConsts(0);
pShader->SetInputFormat(0);
pShader->SetOutputFormat(0);
pShader->SetDecl(plShaderTable::Decl(plShaderID::ps_GrassShader));
hsgResMgr::ResMgr()->SendRef(pShader->GetKey(), TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnRequest, 0, kRefGrassPS), plRefFlags::kActiveRef);
}
plLayer* layer = plLayer::ConvertNoRef(fMaterial->GetLayer(0)->BottomOfStack());
if (layer && (layer->GetVertexShader() != fVShader))
{
plLayRefMsg* refMsg = TRACKED_NEW plLayRefMsg(layer->GetKey(), plRefMsg::kOnCreate, 0, plLayRefMsg::kVertexShader);
hsgResMgr::ResMgr()->SendRef(fVShader->GetKey(), refMsg, plRefFlags::kActiveRef);
}
if (layer && (layer->GetPixelShader() != fPShader))
{
plLayRefMsg* refMsg = TRACKED_NEW plLayRefMsg(layer->GetKey(), plRefMsg::kOnCreate, 0, plLayRefMsg::kPixelShader);
hsgResMgr::ResMgr()->SendRef(fPShader->GetKey(), refMsg, plRefFlags::kActiveRef);
}
}