bool Bat::collisionOccured(const Character* enemy)
{
if (Monster::collisionOccured(enemy))
{
EffectManager* effectManager = (EffectManager*)this->getParent()->getChildByTag(EFFECT_MANAGER_TAG);
effectManager->createEffect(EffectManager::BAT_DIE, this->getPosition());
return true;
}
return false;
}
void loop()
{
time = millis();
SC.Poll(time);
// PollOffHooks returns
bool offHookRemote = SC.IsOffHookRemote();
bool offHookLocal = SC.IsOffHookLocal();
//bool offHookLocal = time & 2048;
// When low power mode is enabled, notify the EM. When the EM is done
// with its shutdown routine, then outright kill the power.
// Poll whether the power management low power status has changed and act
// on it.
if (PM.Poll(time))
{
if (PM.GetLowPowerStatus() == PM_LOW_POWER_MODE_ON)
{
EM.DisableEffects();
} else {
EM.EnableEffects();
}
}
EM.Poll(time, offHookLocal);
PhoneControl(offHookLocal, offHookRemote);
#ifdef WATCHDOG_ENABLED
if ((time - watchdogTime0) > WATCHDOG_PERIOD_MS)
{
watchdogTime0 = time;
PRINT("* time: ");
PRINTLN((unsigned long) time);
}
#endif
#ifdef BLINK_ENABLED
if ((time - blinkTime0) > BLINK_MS)
{
blinkTime0 = time;
blinkMode = !blinkMode;
digitalWrite(BLINK_PIN, blinkMode ? HIGH : LOW);
}
#endif
// Modulate Framerate a bit
unsigned long dur = millis() - time;
if(dur < 20)
delay(20 - dur);
// Output Random Value for WatchDog 'Duino
digitalWrite(WATCHDOG_PULSE_PIN, ((time >> 8) & 0x1) == 1 ? HIGH : LOW);
}
int main(int argc, char *argv[]) {
std::cout << "Initializing Effect Master 3000..." << std::endl;
signal(SIGINT, SignalHandler);
EffectManager *mgr = EffectManager::getInstance();
Environment *env = mgr->getEnvironment();
env->loadConfig("effectmaster.conf");
if (!createWindow("Effect Master 3000", env->getScreenWidth(), env->getScreenHeight(), env->isFullscreen()) ||
!initOpenGL(env->getScreenWidth(), env->getScreenHeight())) {
std::cout << "Error creating window!" << std::endl;
exit(1);
}
GLenum err = glewInit();
if (GLEW_OK != err) {/* Problem: glewInit failed, something is seriously wrong. */
std::cout << "Error initializing GLEW: " << glewGetErrorString(err) << std::endl;
exit(1);
}
int fps = env->getFps();
int msPerFrame = 1000/fps;
int passedMS = msPerFrame;
unsigned int frameStart = 0;
int rest = 0;
std::cout << "Initialization done!" << std::endl;
mgr->init();
while(!done) {
passedMS = SDL_GetTicks() - frameStart;
frameStart = SDL_GetTicks();
mgr->animate(passedMS);
mgr->draw();
SDL_GL_SwapBuffers();
userInput();
rest = msPerFrame - (SDL_GetTicks() - frameStart);
if (rest < 0 )
rest = 0;
SDL_Delay(rest);
}
std::cout << "Shutting down Effect Master 3000..." << std::endl;
delete env;
delete mgr;
return 0;
}
EffectManager* EffectManager::create()
{
EffectManager *pRet = new EffectManager();
if (pRet!=nullptr)
{
pRet->init();
pRet->autorelease();
return pRet;
}
else
{
delete pRet;
pRet = NULL;
return NULL;
}
}
/**
* @brief
* Constructor
*/
Effect::Effect(EffectManager &cManager, const String &sName) : PLCore::Resource<Effect>(sName, &cManager),
m_pParameterManager(new ParameterManager(cManager.GetRendererContext())),
m_nFlags(0),
m_bBlend(false),
m_nSelectedTechnique(-1)
{
}
EffectManager::EffectManager(Widget *parent) :
Widget(Rect(0, 0, GRSYS_WIDTH, GRSYS_HEIGHT), parent),
m_isActive(false)
{
auto event = [](Timer *timer) {
EffectManager *self = (EffectManager*)timer->userData();
self->timerEvent();
};
setFullScreenBlock(false);
setBlockable(false);
timer.setUserData(this);
timer.timerEventSignal().connect( event );
memset(&prev_img, 0, sizeof(prev_img));
memset(&next_img, 0, sizeof(next_img));
}
void setup()
{
state = STATE_IDLE;
// Pin assignments
#ifdef USE_UART
SERIAL.begin(SERIAL_RATE);
PRINTLN("START");
#endif
EM.AddEffectsArrays
(
effectsIdle, EFFECTS_NUM_IDLE, // Effects array, length
effectsRing, EFFECTS_NUM_RING,
effectsCall, EFFECTS_NUM_CALL,
effectsOver, EFFECTS_NUM_OVER
);
EM.SetMode(EM_MODE_IDLE);
EM.InitHardware();
SC.InitPins();
PM.InitPins();
time = millis();
#ifdef DEBUG
debugState = -1;
#endif
#ifdef BLINK_ENABLED
blinkMode = false;
pinMode(BLINK_PIN, OUTPUT);
blinkTime0 = time;
#endif
#ifdef WATCHDOG_ENABLED
watchdogTime0 = time;
#endif
//EM.InstallAnimator();
EM.RebootPanels();
while (!EM.RebootComplete())
{
PM.Poll(millis());
}
}
bool EventHandler::keyPressed( const KeyEvent &arg )
{
switch (arg.key)
{
// Quit.
case KC_ESCAPE:
_pApplication->stop();
break;
// Help.
case KC_H:
_pApplication->printHelp();
break;
// Change current joystick.
case KC_RIGHT:
_pEffectMgr->selectEffect(EffectManager::eNone);
_pJoystickMgr->selectJoystick(JoystickManager::eNext);
_pEffectMgr->checkPlayableEffects();
break;
case KC_LEFT:
_pEffectMgr->selectEffect(EffectManager::eNone);
_pJoystickMgr->selectJoystick(JoystickManager::ePrevious);
_pEffectMgr->checkPlayableEffects();
break;
// Change current effect.
case KC_UP:
_pEffectMgr->selectEffect(EffectManager::eNext);
break;
case KC_DOWN:
_pEffectMgr->selectEffect(EffectManager::ePrevious);
break;
// Change current master gain.
case KC_PGUP:
_pJoystickMgr->changeMasterGain(5.0); // Percent
break;
case KC_PGDOWN:
_pJoystickMgr->changeMasterGain(-5.0); // Percent
break;
// Toggle auto-center mode.
case KC_SPACE:
_pJoystickMgr->changeAutoCenter();
break;
default:
cout << "Non mapped key: " << arg.key << endl;
}
return true;
}
void printHelp()
{
cout << endl
<< "Keyboard actions :" << endl
<< "* Escape : Exit App" << endl
<< "* H : This help menu" << endl
<< "* Right/Left : Select next/previous joystick among the FF capable detected ones" << endl
<< "* Up/Down : Select next/previous effect for the selected joystick" << endl
<< "* PgUp/PgDn : Increase/decrease from 5% the master gain "
<< "for all the joysticks" << endl
<< "* Space : Toggle auto-centering on all the joysticks" << endl;
if (_bIsInitialized)
{
cout << endl << "Implemented effects :" << endl << endl;
_pEffectMgr->printEffects();
cout << endl;
}
}
void CMiniSceneGraph::Draw_Internal(float fDeltaTime)
{
PERF1("MiniSceneGraph_Draw");
SceneState& sceneState = m_sceneState;
m_sceneState.m_pd3dDevice = CGlobals::GetRenderDevice();
RenderDevicePtr pd3dDevice = m_sceneState.m_pd3dDevice;
EffectManager* pEffectManager = CGlobals::GetEffectManager();
bool old_IsLocalLightEnabled = pEffectManager->IsLocalLightingEnabled();
IScene * pOldScene = pEffectManager->GetScene();
pEffectManager->SetScene(this);
//////////////////////////////////////////////////////////////////////////
// Set some initial states for the normal pipeline
LinearColor fogColor = GetSunLight().ComputeFogColor();
fogColor.r *= GetFogColorFactor().r;
fogColor.g *= GetFogColorFactor().g;
fogColor.b *= GetFogColorFactor().b;
SetFogColor(fogColor);
pEffectManager->EnableFog(IsFogEnabled());
pEffectManager->SetD3DFogState();
#ifdef USE_DIRECTX_RENDERER
pd3dDevice->SetMaterial((D3DMATERIAL9*)&(sceneState.GetGlobalMaterial()));
#elif defined(USE_OPENGL_RENDERER)
if (!IsSunLightEnabled())
{
// sun light can not be disabled in shader, so we will fake it here. Remove this when shader support turn off global sun light.
GetSunLight().SetSunAmbient(LinearColor::White);
GetSunLight().SetSunDiffuse(LinearColor::Black);
}
#endif
// disable local lights on bipeds
if(old_IsLocalLightEnabled)
pEffectManager->EnableLocalLighting(false);
// end previous effects, since they may serve different IScene instance.
pEffectManager->EndEffect();
// copy the main scene's state
sceneState.m_pCurrentEffect = pEffectManager->GetCurrentEffectFile();
// rebuild scene state
sceneState.dTimeDelta = fDeltaTime;
PrepareRender(m_pCamera, &sceneState);
{
// all render code goes here
/**
All potentially visible scene objects in the scene state are put to three major post rendering lists for rendering.
Each list is sorted according to object-to-camera distance. And then they will be rendered in the following order:
- solid object list: sorted from front to back. In mesh report, it will display "F->B:%d". Their bounding boxes will be rendered as red boxes.
- transparent object list: sorted from back to front. In mesh report, it will display "B->F:%d(%d1)".
where %d is the total number of meshes rendered and that %d1 is the number of meshes that has been occluded during occlusion testing.
Their bounding boxes will be rendered as blue boxes.
- Biped list: sorted by primary asset. In mesh report, it will display "Biped:%d". Their bounding boxes will be rendered as green boxes.
*/
{
// so that mesh and character that contains translucent faces are sorted and rendered later on.
if(!sceneState.GetFaceGroups()->IsEmpty())
{
sceneState.GetFaceGroups()->Clear();
}
sceneState.m_bEnableTranslucentFaceSorting = true;
// object num in potentially visible set from current view point
int nPVSCount = 0;
//////////////////////////////////////////////////////////////////////////
/// Draw SkyBox
RenderSelection(RENDER_SKY_BOX);
//////////////////////////////////////////////////////////////////////////
/// draw solid object rendering list from front to back.
if(!sceneState.listPRSolidObject.empty())
{
RenderSelection(RENDER_MESH_FRONT_TO_BACK);
}
//////////////////////////////////////////////////////////////////////////
// draw smaller object rendering list from back to front.
if(!sceneState.listPRSmallObject.empty())
{
nPVSCount = RenderSelection(RENDER_MESH_BACK_TO_FRONT);
}
//////////////////////////////////////////////////////////////////////////
/// Draw queued bipeds
/// we draw biped after its shadow, because we do not want biped to cast shadows on its own
if(!sceneState.listPRBiped.empty())
{
RenderSelection(RENDER_CHARACTERS);
}
//////////////////////////////////////////////////////////////////////////
// draw transparent object rendering list from back to front.it is rendered after ocean to prevent the ocean color over the particles.
if(!sceneState.listPRTransparentObject.empty())
{
RenderSelection(RENDER_MESH_TRANSPARENT);
}
//////////////////////////////////////////////////////////////////////////
// render translucent face groups.
if(!sceneState.GetFaceGroups()->IsEmpty())
{
// translucent faces are ignored.
RenderSelection(RENDER_TRANSLUCENT_FACE_GROUPS);
sceneState.GetFaceGroups()->Clear();
}
//////////////////////////////////////////////////////////////////////////
/// render all particle system instances after most of the scene have been rendered.
/// it is rendered after ocean to prevent the ocean color over the particles. since all particles are z write disabled.
{
int nParticlesCount = RenderSelection(RENDER_PARTICLES, fDeltaTime);
}
//////////////////////////////////////////////////////////////////////////
// bounding box
if(CGlobals::GetScene()->IsShowBoundingBox())
RenderSelection(RENDER_BOUNDINGBOX);
//////////////////////////////////////////////////////////////////////////
// portal
if(CGlobals::GetScene()->IsPortalSystemShown())
RenderSelection(RENDER_PORTAL_SYSTEM);
}
}
#ifdef USE_DIRECTX_RENDERER
if(m_pMask!=0 && pEffectManager->BeginEffect(TECH_GUI, &(m_sceneState.m_pCurrentEffect)))
{
/** draw the mask square in front of the screen. */
CEffectFile* pEffectFile = CGlobals::GetEffectManager()->GetCurrentEffectFile();
if(pEffectFile == 0)
{
//////////////////////////////////////////////////////////////////////////
// fixed programming pipeline
float sx = (float)m_nTextureWidth,sy = (float)m_nTextureHeight;
DXUT_SCREEN_VERTEX v[10];
v[0].x = 0; v[0].y = sy; v[0].tu = 0; v[0].tv = 1.0f;
v[1].x = 0; v[1].y = 0; v[1].tu = 0; v[1].tv = 0;
v[2].x = sx; v[2].y = sy; v[2].tu = 1.f; v[2].tv = 1.f;
v[3].x = sx; v[3].y = 0; v[3].tu = 1.f; v[3].tv = 0;
DWORD dwColor = LinearColor(1.f,1.f,1.f,1.f);
int i;
for(i=0;i<4;i++)
{
v[i].color = dwColor;
v[i].z = 0;
v[i].h = 1.0f;
}
//pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 ); // modulate operation
//pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG2 );
//
//pd3dDevice->SetRenderState( D3DRS_COLORWRITEENABLE,
// D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN |
// D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA );
pd3dDevice->SetRenderState( D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_ALPHA );
pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ZERO);
pd3dDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_SRCALPHA);
/*pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP,D3DTOP_SELECTARG2);
pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1,D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG2,D3DTA_CURRENT);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP,D3DTOP_SELECTARG1);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1,D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2,D3DTA_CURRENT);*/
pd3dDevice->SetTexture(0, m_pMask->GetTexture());
RenderDevice::DrawPrimitiveUP( pd3dDevice, RenderDevice::DRAW_PERF_TRIANGLES_MESH, D3DPT_TRIANGLESTRIP, 2, v, sizeof(DXUT_SCREEN_VERTEX) );
/*pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP,D3DTOP_MODULATE);
pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1,D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG2,D3DTA_CURRENT);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP,D3DTOP_SELECTARG1);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1,D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2,D3DTA_CURRENT);*/
pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
pd3dDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
pd3dDevice->SetRenderState( D3DRS_COLORWRITEENABLE,
D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN |
D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA );
}
}
#endif
// draw the head on display GUI
RenderHeadOnDisplay();
//////////////////////////////////////////////////////////////////////////
// Restore state for the normal pipeline
pEffectManager->SetScene(pOldScene);
// enable fog
pEffectManager->EnableFog(CGlobals::GetScene()->IsFogEnabled());
// restore the main scene's state
CGlobals::GetSceneState()->m_pCurrentEffect = sceneState.m_pCurrentEffect;
if(old_IsLocalLightEnabled)
pEffectManager->EnableLocalLighting(old_IsLocalLightEnabled);
}
HRESULT BMaxObject::Draw(SceneState * sceneState)
{
if (!m_pAnimatedMesh)
return E_FAIL;
if (GetPrimaryTechniqueHandle() < 0)
{
// try loading the asset if it has not been done before.
m_pAnimatedMesh->LoadAsset();
if (m_pAnimatedMesh->IsLoaded())
{
SetPrimaryTechniqueHandle(m_pAnimatedMesh->GetPrimaryTechniqueHandle());
UpdateGeometry();
}
return E_FAIL;
}
if (!CGlobals::GetEffectManager()->IsCurrentEffectValid())
{
return E_FAIL;
}
sceneState->SetCurrentSceneObject(this);
int nIndex = (sceneState && sceneState->IsLODEnabled()) ?
m_pAnimatedMesh->GetLodIndex(sceneState->GetCameraToCurObjectDistance()/*, GetScaling()*/) : 0;
CParaXModel* pModel = m_pAnimatedMesh->GetModel(nIndex);
if (pModel == NULL)
return E_FAIL;
int nRestoreSpecialTextures = -1;
for (auto const & tex : mReplaceTextures)
{
if(pModel->specialTextures[tex.first] >= 0)
pModel->replaceTextures[pModel->specialTextures[tex.first]] = tex.second;
else
{
// if there is only one texture, we will force replace it even there is no special replaceable id redefined.
if (pModel->GetObjectNum().nTextures <= 1 && nRestoreSpecialTextures<0)
{
nRestoreSpecialTextures = tex.first;
pModel->specialTextures[tex.first] = tex.first;
pModel->replaceTextures[pModel->specialTextures[tex.first]] = tex.second;
break;
}
}
}
sceneState->SetCurrentSceneObject(this);
SetFrameNumber(sceneState->m_nRenderCount);
// get world transform matrix
Matrix4 mxWorld;
GetRenderMatrix(mxWorld);
RenderDevicePtr pd3dDevice = sceneState->m_pd3dDevice;
EffectManager* pEffectManager = CGlobals::GetEffectManager();
pEffectManager->applyObjectLocalLighting(this);
CEffectFile* pEffectFile = pEffectManager->GetCurrentEffectFile();
CGlobals::GetWorldMatrixStack().push(mxWorld);
ApplyBlockLighting(sceneState);
CApplyObjectLevelParamBlock p(GetEffectParamBlock());
if (pEffectFile == 0)
{
// TODO: Fixed Function.
}
else
{
bool bUsePointTextureFilter = false;
// apply block space lighting for object whose size is comparable to a single block size
if (CheckAttribute(MESH_USE_LIGHT) && !(sceneState->IsShadowPass()))
{
BlockWorldClient* pBlockWorldClient = BlockWorldClient::GetInstance();
if (pBlockWorldClient && pBlockWorldClient->IsInBlockWorld())
{
Vector3 vPos = GetPosition();
vPos.y += 0.1f;
Uint16x3 blockId_ws(0, 0, 0);
BlockCommon::ConvertToBlockIndex(vPos.x, vPos.y, vPos.z, blockId_ws.x, blockId_ws.y, blockId_ws.z);
DWORD dwPositionHash = blockId_ws.GetHashCode();
uint8_t brightness[2];
pBlockWorldClient->GetBlockMeshBrightness(blockId_ws, brightness, 2);
// block light
float fBlockLightness = Math::Max(pBlockWorldClient->GetLightBrightnessLinearFloat(brightness[0]), 0.1f);
sceneState->GetCurrentLightStrength().y = fBlockLightness;
// sun light
float fSunLightness = Math::Max(pBlockWorldClient->GetLightBrightnessLinearFloat(brightness[1]), 0.1f);
sceneState->GetCurrentLightStrength().x = fSunLightness;
float fLightness = Math::Max(fBlockLightness, fSunLightness*pBlockWorldClient->GetSunIntensity());
if (m_fLastBlockLight != fLightness)
{
float fMaxStep = (float)(sceneState->dTimeDelta*0.5f);
if (dwPositionHash == m_dwLastBlockHash || m_dwLastBlockHash == 0)
m_fLastBlockLight = fLightness;
else
Math::SmoothMoveFloat1(m_fLastBlockLight, fLightness, fMaxStep);
fLightness = m_fLastBlockLight;
}
else
{
m_dwLastBlockHash = dwPositionHash;
}
sceneState->GetLocalMaterial().Ambient = (LinearColor(fLightness*0.7f, fLightness*0.7f, fLightness*0.7f, 1.f));
sceneState->GetLocalMaterial().Diffuse = (LinearColor(fLightness*0.4f, fLightness*0.4f, fLightness*0.4f, 1.f));
sceneState->EnableLocalMaterial(true);
bUsePointTextureFilter = bUsePointTextureFilter || pBlockWorldClient->GetUsePointTextureFiltering();
}
}
if (bUsePointTextureFilter)
{
pEffectManager->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_POINT);
pEffectManager->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_POINT);
}
else
{
pEffectManager->SetSamplerState(0, D3DSAMP_MINFILTER, pEffectManager->GetDefaultSamplerState(0, D3DSAMP_MINFILTER));
pEffectManager->SetSamplerState(0, D3DSAMP_MAGFILTER, pEffectManager->GetDefaultSamplerState(0, D3DSAMP_MAGFILTER));
}
// just a single standing animation is supported now and looped.
UpdateModel(sceneState);
pModel->draw(sceneState, p.GetParamsBlock());
}
if (nRestoreSpecialTextures >= 0)
{
pModel->specialTextures[nRestoreSpecialTextures] = -1;
pModel->replaceTextures[nRestoreSpecialTextures] = nullptr;
}
CGlobals::GetWorldMatrixStack().pop();
return S_OK;
}
//////////////////////////////////////////////////////////////////////////////
// 뱀파이어 셀프 핸들러
//////////////////////////////////////////////////////////////////////////////
void SummonCasket::execute(Vampire* pVampire, VampireSkillSlot* pSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;
Assert(pVampire != NULL);
Assert(pSkillSlot != NULL);
//cout << "SummonCasket try.." << endl;
try
{
Player* pPlayer = pVampire->getPlayer();
Zone* pZone = pVampire->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
if (!pVampire->isVampire()
&& !pVampire->isMonster())
{
executeSkillFailNormal(pVampire, getSkillType(), NULL);
return;
}
GCSkillToSelfOK1 _GCSkillToSelfOK1;
GCSkillToSelfOK3 _GCSkillToSelfOK3;
SkillType_t SkillType = pSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
ZoneCoord_t x = pVampire->getX();
ZoneCoord_t y = pVampire->getY();
// Knowledge of Summon 이 있다면 hit bonus 10
int HitBonus = 0;
if (pVampire->hasRankBonus(RankBonus::RANK_BONUS_KNOWLEDGE_OF_SUMMON ) )
{
RankBonus* pRankBonus = pVampire->getRankBonus(RankBonus::RANK_BONUS_KNOWLEDGE_OF_SUMMON);
Assert(pRankBonus != NULL);
HitBonus = pRankBonus->getPoint();
}
int RequiredMP = decreaseConsumeMP(pVampire, pSkillInfo);
bool bManaCheck = hasEnoughMana(pVampire, RequiredMP);
bool bTimeCheck = verifyRunTime(pSkillSlot);
bool bRangeCheck = checkZoneLevelToUseSkill(pVampire);
bool bHitRoll = HitRoll::isSuccessMagic(pVampire, pSkillInfo, pSkillSlot, HitBonus);
bool bTileCheck = canBurrow(pZone, x, y);
bool bMoveModeCheck = pVampire->isWalking();
bool bEffected = pVampire->isFlag(Effect::EFFECT_CLASS_CASKET);
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bTileCheck && bMoveModeCheck && !bEffected)
{
//cout << "SummonCasket Success" << endl;
decreaseMana(pVampire, RequiredMP, _GCSkillToSelfOK1);
SkillInput input(pVampire);
SkillOutput output;
computeOutput(input, output);
// 뱀파이어를 땅 위에서 삭제하기 이전에 기술 패킷들을 날린다.
_GCSkillToSelfOK1.setSkillType(SkillType);
_GCSkillToSelfOK1.setCEffectID(CEffectID);
_GCSkillToSelfOK1.setDuration(output.Duration);
_GCSkillToSelfOK3.setXY(x, y);
_GCSkillToSelfOK3.setSkillType(SkillType);
_GCSkillToSelfOK3.setDuration(output.Duration);
pPlayer->sendPacket(&_GCSkillToSelfOK1);
pZone->broadcastPacket(x, y, &_GCSkillToSelfOK3, pVampire);
//---------------------------------------------------------------
// 기존의 지속 마법 효과를 제거한다.
//---------------------------------------------------------------
EffectManager* pEffectManager = pVampire->getEffectManager();
Assert(pEffectManager!=NULL);
Effect* pCheckEffect = NULL;
// 사용자의 level을 구한다.
int userLevel = pVampire->getLevel();
Effect::EffectClass effectClass;
// EFFECT_CLASS_FLARE
effectClass = Effect::EFFECT_CLASS_FLARE;
pCheckEffect = pEffectManager->findEffect(effectClass);
if (pCheckEffect!=NULL)
{
int level = (dynamic_cast<EffectFlare*>(pCheckEffect))->getLevel();
if (level < userLevel)
{
pEffectManager->deleteEffect(effectClass);
pVampire->removeFlag(effectClass);
}
}
// EFFECT_CLASS_DOOM
effectClass = Effect::EFFECT_CLASS_DOOM;
pCheckEffect = pEffectManager->findEffect(effectClass);
if (pCheckEffect!=NULL)
{
int level = (dynamic_cast<EffectDoom*>(pCheckEffect))->getLevel();
if (level < userLevel)
{
pEffectManager->deleteEffect(effectClass);
pVampire->removeFlag(effectClass);
}
}
// EFFECT_CLASS_SEDUCTION
effectClass = Effect::EFFECT_CLASS_SEDUCTION;
pCheckEffect = pEffectManager->findEffect(effectClass);
if (pCheckEffect!=NULL)
{
int level = (dynamic_cast<EffectSeduction*>(pCheckEffect))->getLevel();
if (level < userLevel)
pEffectManager->deleteEffect(effectClass);
pVampire->removeFlag(effectClass);
}
//---------------------------------------------------------------
// 이펙트 오브젝트를 생성해 붙인다.
//---------------------------------------------------------------
EffectSummonCasket* pEffect = new EffectSummonCasket(pVampire);
pEffect->setDeadline(99999999);
pEffect->setType(0);
pVampire->addEffect(pEffect);
pVampire->setFlag(Effect::EFFECT_CLASS_CASKET);
// SUMMON CASKET 에 의해 변하는 능력치가 변한다.. 2002.12.13 by bezz.
VAMPIRE_RECORD prev;
pVampire->getVampireRecord(prev);
pVampire->initAllStat();
pVampire->sendRealWearingInfo();
pVampire->sendModifyInfo(prev);
GCAddEffect gcAddEffect;
gcAddEffect.setObjectID(pVampire->getObjectID());
gcAddEffect.setEffectID(Effect::EFFECT_CLASS_CASKET);
gcAddEffect.setDuration(output.Duration);
pZone->broadcastPacket(pVampire->getX(), pVampire->getY(), &gcAddEffect, pVampire);
pSkillSlot->setRunTime();
}
else
{
//cout << "SummonCasket Failed" << endl;
executeSkillFailNormal(pVampire, getSkillType(), NULL);
}
}
catch(Throwable & t)
{
//cout << "SummonCasket Failed2" << endl;
executeSkillFailException(pVampire, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__END_CATCH
}
void effect_End(void)
{
g_EffectManager.getEffect().end();
g_EffectManager.bind(0);
}
bool effect_Begin(effect_sig signature)
{
g_EffectManager.bind(signature);
g_EffectManager.getEffect().begin();
return true;
}
namespace Engine {
/** Instantiate the global effect manager singleton */
EffectManager g_EffectManager;
bool effect_Begin(effect_sig signature)
{
g_EffectManager.bind(signature);
g_EffectManager.getEffect().begin();
return true;
}
void effect_End(void)
{
g_EffectManager.getEffect().end();
g_EffectManager.bind(0);
}
EffectManager::EffectManager(void)
{
clear();
}
EffectManager::~EffectManager(void)
{
destroy();
}
void EffectManager::clear(void)
{
currentEffect=0;
currentSig=0;
}
void EffectManager::create(void)
{
destroy();
// Allocate all effects
TRACE("Allocating all Effects");
LinkTable temp;
temp.insert(make_pair(effect_CLASS_Z_ONLY, new Effect_Z_Only));
temp.insert(make_pair(effect_CLASS_PROJECT_SHADOWS, new Effect_Project_Shadows));
temp.insert(make_pair(effect_CLASS_RECEIVE_SHADOWS, new Effect_Receive_Shadows));
temp.insert(make_pair(effect_CLASS_GOURAUD_FFP, new Effect_Gouraud_FFP));
temp.insert(make_pair(effect_CLASS_TEXTURE_REPLACE_FFP, new Effect_TextureReplace_FFP));
temp.insert(make_pair(effect_CLASS_PARTICLE_FX, new Effect_Particle_FFP));
temp.insert(make_pair(effect_CLASS_GUI, new Effect_GUI_FFP));
temp.insert(make_pair(effect_CLASS_RED, new Effect_Red_FFP));
// Iterate through effects and eliminate effects that are not supported
TRACE("Determining supported Effects");
for(LinkTable::iterator iter = temp.begin(); iter!=temp.end(); ++iter)
{
Effect *effect = (iter->second);
ASSERT(effect != 0, "null Effect");
// Do we have enough texture units to use the effect?
if(effect->getRequiredTextureUnits() > g_MultitextureUnits)
{
// Discard the effect and continue
TRACE(effect->getName() + ": Effect requires too many texture stages, discarding...");
delete effect;
continue;
}
// Do we have the extension support?
else if(!isSupported(effect->getRequiredExtensions()))
{
// Discard the effect and continue
TRACE(effect->getName() + ": Effect requires unsupported or disabled extensions, discarding...");
//delete effect;
continue;
}
// Effect is supported
else
{
rawEffects.insert(make_pair(iter->first, iter->second));
}
}
// Initialize all effect classes
TRACE("Initializing the supported Effects");
for(LinkTable::iterator iter = rawEffects.begin(); iter!=rawEffects.end(); ++iter)
{
(iter->second)->create();
}
// Then, insert those effects that are supported into the link table
for(effect_sig i = 1; i<effect_CLASS_MAX; ++i)
{
Effect *effect = queryRaw(i);
ASSERT(effect!=0, "EffectManager::create -> Effect was NULL");
linkTable.insert(make_pair(i, effect));
}
// Determine the best fit effects for the templated effect signatures
// These are the effects we will work with to link together
effect_sig effects[] =
{
effect_DEFAULT,
effect_TEXTURE_REPLACE,
effect_NO_TEXTURE_LIT,
effect_TEXTURE_LIT,
effect_GUI,
effect_PARTICLE_FX,
effect_TRANSPARENT,
effect_RED
};
// For each effect signature:
TRACE("Linking Effects to effect signature templates");
for(size_t i=0; i<sizeof(effects); ++i)
{
priority_queue< pair<int,Effect*>, vector< pair<int,Effect*> >, less< pair<int,Effect*> > > options;
effect_sig sig = effects[i];
// For each effect class, determine the priority for this signature
for(LinkTable::iterator iter = rawEffects.begin(); iter!=rawEffects.end(); ++iter)
{
options.push( make_pair( (iter->second)->howGood(sig), iter->second ) );
}
// Select the highest priority for this signature
Effect *best = options.top().second;
// Link to the best effect that was found for this signature
linkTable.insert( make_pair(sig, best) );
}
// select no initial Effect
currentEffect = 0;
TRACE("Completed");
}
void EffectManager::destroy(void)
{
TRACE("Destroying existing Effects");
clear();
}
bool EffectManager::bind(effect_sig signature)
{
if(signature==0)
{
currentEffect = 0;
}
else
{
// First, make sure there isn't already an active effect
ASSERT(currentEffect==0, "there is already an active effect!");
// What effect best matches the requested signature?
Effect *requested = query(signature);
ASSERT(requested != 0, "Effect was NULL, linker should have taken care of that!");
currentEffect = requested;
currentSig = signature;
}
// Indicate that we did change the Effect
return true;
}
Effect& EffectManager::getEffect(void)
{
ASSERT(currentEffect!=0, "There is currently no bound effect!");
return(*currentEffect);
}
Effect* EffectManager::queryRaw(effect_sig signature)
{
ASSERT(!rawEffects.empty(), "EffectManager::queryRaw -> rawEffects was empty");
LinkTable::iterator iter = rawEffects.find(signature);
LinkTable::iterator _end = rawEffects.end();
if(iter != _end)
{
return(iter->second);
}
else
{
// Some default effect
return(rawEffects.begin()->second);
}
}
Effect* EffectManager::query(effect_sig signature)
{
LinkTable::iterator iter = linkTable.find(signature);
if(iter != linkTable.end())
{
return(iter->second);
}
else
{
return 0;
}
}
bool EffectManager::isSupported(const string &str)
{
tokenizer<> extensions(str);
for(tokenizer<>::const_iterator iter = extensions.begin(); iter != extensions.end(); ++iter)
{
if(glewIsSupported((*iter).c_str())==GL_FALSE)
return false;
}
return true;
}
} // namespace Engine
void MonsterInfo::ShowCompleteMonsterInfo(MonsterData* monster)
{
int i;
for (i = 3; i < 30; i++)
World.getTextManager().SetDisplayLine(i, "");
char buf[128];
World.getTextManager().SetDisplayLine(0, "%s", monster->monster.name.c_str());
World.getTextManager().SetDisplayLine(1, "==========");
World.getTextManager().SetDisplayLine(3, "");
sprintf(buf, "Stamina: %d", monster->Stamina());
World.getTextManager().SetDisplayLine(5, buf);
sprintf(buf, "Skill: %d(+%d)", monster->AdjustedSkill(), monster->AdjustedSkill() - monster->Skill());
World.getTextManager().SetDisplayLine(6, buf);
switch (monster->GetState())
{
case asleep: sprintf(buf, "State: asleep"); break;
case sentry: sprintf(buf, "State: sentry"); break;
case normal: sprintf(buf, "State: normal"); break;
case hostile: sprintf(buf, "State: hostile"); break;
case dead: sprintf(buf, "State: dead"); break;
}
World.getTextManager().SetDisplayLine(7, buf);
sprintf(buf, "Experience: %d", monster->experience);
World.getTextManager().SetDisplayLine(8, buf);
sprintf(buf, "Experience Level: %d", monster->experience_level);
World.getTextManager().SetDisplayLine(9, buf);
sprintf(buf, "Kills: %d", monster->Kills());
World.getTextManager().SetDisplayLine(10, buf);
sprintf(buf, "Dungeon Level: %d", monster->level);
World.getTextManager().SetDisplayLine(11, buf);
sprintf(buf, "Inventory Items %d", monster->inventory.size());
World.getTextManager().SetDisplayLine(13, buf);
ITEMLIST::iterator it;
i = 15;
for (it = monster->inventory.begin(); it != monster->inventory.end(); it++, i++)
{
// if(it->equipped)
{
World.getTextManager().SetDisplayLine(i, "%s", it->GetName().c_str());
}
}
i++;
World.getTextManager().SetDisplayLine(i++, "Effects");
EffectManager effectManager;
EFFECTLIST::iterator eff;
for (eff = monster->monster.effectList.begin(); eff != monster->monster.effectList.end(); eff++, i++)
{
if (eff->strength > 0)
World.getTextManager().SetDisplayLine(i, (char*)effectManager.EffectName(eff->type).c_str());
}
/*EFFECTMAP_CITERATOR eff;
for(eff=monster->monster.effectMap.begin();eff != monster->monster.effectMap.end();it++,i++)
{
if(eff->second > 0)
World.getTextManager().SetDisplayLine(i,(char*)effectManager.EffectName(eff->first).c_str());
}*/
World.getTextManager().SetDisplayLine(39, "[x] to Exit");
}
//////////////////////////////////////////////////////////////////////////////
// 슬레이어 셀프 핸들러
//////////////////////////////////////////////////////////////////////////////
void OpenCasket::execute(Vampire* pVampire, VampireSkillSlot* pVampireSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin(slayerself)" << endl;
Assert(pVampire != NULL);
//Assert(pVampireSkillSlot != NULL);
//cout << "Open Casket" << endl;
try
{
Player* pPlayer = pVampire->getPlayer();
Zone* pZone = pVampire->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
GCSkillToSelfOK1 _GCSkillToSelfOK1;
GCSkillToSelfOK2 _GCSkillToSelfOK2;
SkillType_t SkillType = getSkillType();
//SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
// 관 속에 들어있는 경우만 사용 가능하다.
bool bEffected = pVampire->isFlag(Effect::EFFECT_CLASS_CASKET);
if (bEffected)
{
//cout << "Open Casket Succeed" << endl;
// 이펙트 클래스를 만들어 붙인다.
EffectManager* pEffectManager = pVampire->getEffectManager();
Assert(pEffectManager!=NULL);
Effect* pEffect = pEffectManager->findEffect(Effect::EFFECT_CLASS_CASKET);
if (pEffect!=NULL)
{
pEffect->setDeadline(0);
// pEffect->unaffect();
// pEffectManager->deleteEffect(Effect::EFFECT_CLASS_CASKET);
// pVampire->removeFlag(Effect::EFFECT_CLASS_CASKET);
}
// 패킷을 만들어 보낸다.
_GCSkillToSelfOK1.setSkillType(SkillType);
_GCSkillToSelfOK1.setCEffectID(CEffectID);
_GCSkillToSelfOK1.setDuration(0);
_GCSkillToSelfOK2.setObjectID(pVampire->getObjectID());
_GCSkillToSelfOK2.setSkillType(SkillType);
_GCSkillToSelfOK2.setDuration(0);
pPlayer->sendPacket(&_GCSkillToSelfOK1);
pZone->broadcastPacket(pVampire->getX(), pVampire->getY(), &_GCSkillToSelfOK2, pVampire);
// set Next Run Time
//pVampireSkillSlot->setRunTime(output.Delay);
}
else
{
//cout << "Open Casket Failed1" << endl;
executeSkillFailNormal(pVampire, getSkillType(), NULL);
}
}
catch (Throwable & t)
{
//cout << "Open Casket Failed2" << endl;
executeSkillFailException(pVampire, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End(slayerself)" << endl;
__END_CATCH
}
void ActionHeal::execute (Creature * pCreature1 , Creature * pCreature2)
throw(Error)
{
__BEGIN_TRY
Assert(pCreature1 != NULL);
Assert(pCreature2 != NULL);
Assert(pCreature1->isNPC());
Assert(pCreature2->isPC());
Player* pPlayer = pCreature2->getPlayer();
Zone* pZone = pCreature2->getZone();
Assert(pPlayer != NULL);
// 일단 클라이언트를 위해서 OK 패킷을 함 날린다.
GCNPCResponse okpkt;
okpkt.setCode(NPC_RESPONSE_HEAL);
pPlayer->sendPacket(&okpkt);
// 죽었거나 코마 걸려있으면 안 치료해준다.
if (pCreature2->isDead() || pCreature2->isFlag(Effect::EFFECT_CLASS_COMA ) )
{
return;
}
// 슬레이어라면...
if (pCreature2->isSlayer())
{
Slayer* pSlayer = dynamic_cast<Slayer*>(pCreature2);
EffectManager* pEffectManager = pSlayer->getEffectManager();
GCModifyInformation modifyPkt;
GCRemoveEffect removePkt;
GCStatusCurrentHP hpPkt;
// 먼저 HP랑 MP를 풀로 채워준다.
if (pSlayer->getHP(ATTR_CURRENT) < pSlayer->getHP(ATTR_MAX))
{
pSlayer->setHP(pSlayer->getHP(ATTR_MAX), ATTR_CURRENT);
modifyPkt.addShortData(MODIFY_CURRENT_HP, pSlayer->getHP(ATTR_CURRENT));
hpPkt.setObjectID(pSlayer->getObjectID());
hpPkt.setCurrentHP(pSlayer->getHP(ATTR_CURRENT));
}
if (pSlayer->getMP(ATTR_CURRENT) < pSlayer->getMP(ATTR_MAX))
{
pSlayer->setMP(pSlayer->getMP(ATTR_MAX), ATTR_CURRENT);
modifyPkt.addShortData(MODIFY_CURRENT_MP, pSlayer->getMP(ATTR_CURRENT));
}
// 흡혈 이펙트를 삭제한다.
Effect* pBloodDrainEffect = pEffectManager->findEffect(Effect::EFFECT_CLASS_BLOOD_DRAIN);
if (pBloodDrainEffect != NULL)
{
// DB에서 삭제하고, 이펙트 매니저에서 삭제한다.
pBloodDrainEffect->destroy(pSlayer->getName());
pEffectManager->deleteEffect(pSlayer, Effect::EFFECT_CLASS_BLOOD_DRAIN);
// 흡혈 아르바이트를 방지하기 위한 후유증 이펙트를 붙여준다.
if (pSlayer->isFlag(Effect::EFFECT_CLASS_AFTERMATH))
{
Effect* pEffect = pEffectManager->findEffect(Effect::EFFECT_CLASS_AFTERMATH);
EffectAftermath* pEffectAftermath = dynamic_cast<EffectAftermath*>(pEffect);
pEffectAftermath->setDeadline(5*600); // 5분 동안 지속된다.
}
else
{
EffectAftermath* pEffectAftermath = new EffectAftermath(pSlayer);
pEffectAftermath->setDeadline(5*600); // 5분 동안 지속된다.
pEffectManager->addEffect(pEffectAftermath);
pSlayer->setFlag(Effect::EFFECT_CLASS_AFTERMATH);
pEffectAftermath->create(pSlayer->getName());
}
// 패킷에다 정보를 더한다.
removePkt.addEffectList((EffectID_t)Effect::EFFECT_CLASS_BLOOD_DRAIN);
// 흡혈을 치료하면 능력치가 변화하게 된다.
SLAYER_RECORD prev;
pSlayer->getSlayerRecord(prev);
pSlayer->initAllStat();
pSlayer->sendModifyInfo(prev);
pSlayer->sendRealWearingInfo();
}
// 독 이펙트를 삭제한다.
Effect* pEffectPoison = pEffectManager->findEffect(Effect::EFFECT_CLASS_POISON);
if (pEffectPoison != NULL)
{
// 이펙트 매니저에서 삭제한다.
pEffectManager->deleteEffect(pSlayer, Effect::EFFECT_CLASS_POISON);
// 패킷에다 정보를 더한다.
removePkt.addEffectList((EffectID_t)Effect::EFFECT_CLASS_POISON);
}
// 다크블루 포이즌 이펙트를 삭제한다.
Effect* pEffectDarkBluePoison = pEffectManager->findEffect(Effect::EFFECT_CLASS_DARKBLUE_POISON);
if (pEffectDarkBluePoison != NULL)
{
// 이펙트 매니저에서 삭제한다.
pEffectManager->deleteEffect(pSlayer, Effect::EFFECT_CLASS_DARKBLUE_POISON);
// 패킷에다 정보를 더한다.
removePkt.addEffectList((EffectID_t)Effect::EFFECT_CLASS_DARKBLUE_POISON);
}
// 패킷 날려준다.
removePkt.setObjectID(pSlayer->getObjectID());
pPlayer->sendPacket(&modifyPkt);
pZone->broadcastPacket(pSlayer->getX(), pSlayer->getY(), &removePkt);
pZone->broadcastPacket(pSlayer->getX(), pSlayer->getY(), &hpPkt, pSlayer);
//log(LOG_HEAL, pSlayer->getName(), "");
}
else if (pCreature2->isVampire())
{
Vampire* pVampire = dynamic_cast<Vampire*>(pCreature2);
//EffectManager* pEffectManager = pVampire->getEffectManager();
GCModifyInformation modifyPkt;
GCRemoveEffect removePkt;
GCStatusCurrentHP hpPkt;
// HP 채워주고...
if (pVampire->getHP(ATTR_CURRENT) < pVampire->getHP(ATTR_MAX))
{
pVampire->setHP(pVampire->getHP(ATTR_MAX), ATTR_CURRENT);
modifyPkt.addShortData(MODIFY_CURRENT_HP, pVampire->getHP(ATTR_CURRENT));
hpPkt.setObjectID(pVampire->getObjectID());
hpPkt.setCurrentHP(pVampire->getHP(ATTR_CURRENT));
}
// 패킷 날려준다.
removePkt.setObjectID(pVampire->getObjectID());
pPlayer->sendPacket(&modifyPkt);
pZone->broadcastPacket(pVampire->getX(), pVampire->getY(), &removePkt);
pZone->broadcastPacket(pVampire->getX(), pVampire->getY(), &hpPkt, pVampire);
//log(LOG_HEAL, pVampire->getName(), "");
}
else if (pCreature2->isOusters())
{
Ousters* pOusters = dynamic_cast<Ousters*>(pCreature2);
EffectManager* pEffectManager = pOusters->getEffectManager();
GCModifyInformation modifyPkt;
GCRemoveEffect removePkt;
GCStatusCurrentHP hpPkt;
// 먼저 HP랑 MP를 풀로 채워준다.
if (pOusters->getHP(ATTR_CURRENT) < pOusters->getHP(ATTR_MAX) || pOusters->getSilverDamage() != 0 )
{
Silver_t prev = pOusters->getSilverDamage();
if (prev != 0 )
{
pOusters->setSilverDamage(0);
modifyPkt.addShortData(MODIFY_SILVER_DAMAGE, pOusters->getSilverDamage());
}
pOusters->setHP(pOusters->getHP(ATTR_MAX), ATTR_CURRENT);
modifyPkt.addShortData(MODIFY_CURRENT_HP, pOusters->getHP(ATTR_CURRENT));
hpPkt.setObjectID(pOusters->getObjectID());
hpPkt.setCurrentHP(pOusters->getHP(ATTR_CURRENT));
}
if (pOusters->getMP(ATTR_CURRENT) < pOusters->getMP(ATTR_MAX))
{
pOusters->setMP(pOusters->getMP(ATTR_MAX), ATTR_CURRENT);
modifyPkt.addShortData(MODIFY_CURRENT_MP, pOusters->getMP(ATTR_CURRENT));
}
// 독 이펙트를 삭제한다.
Effect* pEffectPoison = pEffectManager->findEffect(Effect::EFFECT_CLASS_POISON);
if (pEffectPoison != NULL)
{
// 이펙트 매니저에서 삭제한다.
pEffectManager->deleteEffect(pOusters, Effect::EFFECT_CLASS_POISON);
// 패킷에다 정보를 더한다.
removePkt.addEffectList((EffectID_t)Effect::EFFECT_CLASS_POISON);
}
// 다크블루 포이즌 이펙트를 삭제한다.
Effect* pEffectDarkBluePoison = pEffectManager->findEffect(Effect::EFFECT_CLASS_DARKBLUE_POISON);
if (pEffectDarkBluePoison != NULL)
{
// 이펙트 매니저에서 삭제한다.
pEffectManager->deleteEffect(pOusters, Effect::EFFECT_CLASS_DARKBLUE_POISON);
// 패킷에다 정보를 더한다.
removePkt.addEffectList((EffectID_t)Effect::EFFECT_CLASS_DARKBLUE_POISON);
}
// 흡혈 이펙트를 삭제한다.
Effect* pBloodDrainEffect = pEffectManager->findEffect(Effect::EFFECT_CLASS_BLOOD_DRAIN);
if (pBloodDrainEffect != NULL)
{
pBloodDrainEffect->setDeadline(0);
// 흡혈 아르바이트를 방지하기 위한 후유증 이펙트를 붙여준다.
if (pOusters->isFlag(Effect::EFFECT_CLASS_AFTERMATH))
{
Effect* pEffect = pEffectManager->findEffect(Effect::EFFECT_CLASS_AFTERMATH);
EffectAftermath* pEffectAftermath = dynamic_cast<EffectAftermath*>(pEffect);
pEffectAftermath->setDeadline(5*600); // 5분 동안 지속된다.
}
else
{
EffectAftermath* pEffectAftermath = new EffectAftermath(pOusters);
pEffectAftermath->setDeadline(5*600); // 5분 동안 지속된다.
pEffectManager->addEffect(pEffectAftermath);
pOusters->setFlag(Effect::EFFECT_CLASS_AFTERMATH);
pEffectAftermath->create(pOusters->getName());
}
// 패킷에다 정보를 더한다.
removePkt.addEffectList((EffectID_t)Effect::EFFECT_CLASS_BLOOD_DRAIN);
}
// 패킷 날려준다.
removePkt.setObjectID(pOusters->getObjectID());
pPlayer->sendPacket(&modifyPkt);
pZone->broadcastPacket(pOusters->getX(), pOusters->getY(), &removePkt);
pZone->broadcastPacket(pOusters->getX(), pOusters->getY(), &hpPkt, pOusters);
//log(LOG_HEAL, pOusters->getName(), "");
}
__END_CATCH
}
void LevelManager::run()
{
/* Behold, as I have been told
* what follows below
* is very important, you know! */
InputManager *inputManager = InputManager::getInstance();
TimeManager *timeManager = TimeManager::getInstance();
VideoManager *videoManager = VideoManager::getInstance();
EffectManager *effectManager = EffectManager::getInstance();
SketchManager *sketchManager = SketchManager::getInstance();
FPSLogger fps;
float freq_to_update = 1000.0f / 60.0f;
long lastUpdate = timeManager->getTicks();
while(!inputManager->hasQuitEvent()) {
/* Calculate the ticks that have passed. */
long ticks = timeManager->getTicks();
float ms = (float)(ticks - lastUpdate);
lastUpdate = ticks;
/* Cap FPS by sleeping a little. */
if(ms <= freq_to_update) {
float wait = freq_to_update - ms;
timeManager->sleep(wait);
}
/* Update the input state. */
inputManager->update(ms);
/* Update the level. */
if(level && ms > 0.0f) level->update(timeFactor * ms);
/* Update other things. */
effectManager->update(timeFactor * ms);
fps.update(ms);
/* Setup the videoManager for rendering. */
videoManager->clear();
videoManager->identity();
/* Render the level first, this will also apply our camera
* transformation, which is good, since the effect manager
* wants the same transformation. */
if(level) level->render();
effectManager->render();
fps.render();
/* Flip the video buffer. */
videoManager->flip();
/* Update level queue. */
if(queue) {
/* Remove old level. */
if(level)
delete level;
effectManager->clear();
sketchManager->clear();
/* Load new level. */
level = new Level(queueFileName);
queue = false;
timeFactor = 1.0f;
/* Loading the level might have taken some time, so we skip
* some ticks. */
lastUpdate = timeManager->getTicks();
}
}
}
void C3DCanvas::Draw(float fDeltaTime)
{
CBaseObject* pActor = GetActor();
if(!IsEnabled() || pActor==0)
return;
if(m_bNeedUpdate == false)
return;
if(!m_bInitialized)
{
InitDeviceObjects();
RestoreDeviceObjects();
}
if(m_pCanvasSurface == 0 || m_pDepthStencilSurface==0)
return;
if(m_bAutoRotate)
{
m_camera.Rotate(0,0.3f*fDeltaTime, 0);
}
m_bNeedUpdate = false;
EffectManager* pEffectManager = CGlobals::GetEffectManager();
LPDIRECT3DDEVICE9 pd3dDevice = CGlobals::GetRenderDevice();
LPDIRECT3DSURFACE9 pOldRenderTarget = CGlobals::GetDirectXEngine().GetRenderTarget();
CGlobals::GetDirectXEngine().SetRenderTarget(0, m_pCanvasSurface);
// save old render origin
Vector3 vOldRenderOrigin = CGlobals::GetScene()->GetRenderOrigin();
// set depth surface
LPDIRECT3DSURFACE9 pOldZBuffer = NULL;
if(FAILED(pd3dDevice->GetDepthStencilSurface(&pOldZBuffer)))
return;
pd3dDevice->SetDepthStencilSurface( m_pDepthStencilSurface );
// save old actor position
pActor->PushParam();
pActor->SetPosition(m_vActorPosition);
pActor->SetFacing(m_fActorFacing);
// animate the camera and push result to transformation stack
m_camera.FrameMove(fDeltaTime);
CGlobals::GetProjectionMatrixStack().push(*m_camera.GetProjMatrix());
CGlobals::GetViewMatrixStack().push(*m_camera.GetViewMatrix());
CGlobals::GetEffectManager()->UpdateD3DPipelineTransform(true,true, true);
// clear
pd3dDevice->Clear(0L, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, COLOR_RGBA(0, 0, 0, 0), 1.0f, 0L);
// disable fog
pEffectManager->EnableFog(false);
if(pEffectManager->BeginEffect(pActor->GetPrimaryTechniqueHandle(), &(CGlobals::GetSceneState()->m_pCurrentEffect)))
{
/** draw the main stage object */
pActor->Draw(CGlobals::GetSceneState());
CGlobals::GetSceneState()->GetFaceGroups()->Clear();
}
if(m_pMask!=0 && pEffectManager->BeginEffect(TECH_GUI, &(CGlobals::GetSceneState()->m_pCurrentEffect)))
{
/** draw the mask square in front of the screen. */
CEffectFile* pEffectFile = CGlobals::GetEffectManager()->GetCurrentEffectFile();
if(pEffectFile == 0)
{
//////////////////////////////////////////////////////////////////////////
// fixed programming pipeline
float sx = (float)m_nTextureWidth,sy = (float)m_nTextureHeight;
DXUT_SCREEN_VERTEX v[10];
v[0].x = 0; v[0].y = sy; v[0].tu = 0; v[0].tv = 1.0f;
v[1].x = 0; v[1].y = 0; v[1].tu = 0; v[1].tv = 0;
v[2].x = sx; v[2].y = sy; v[2].tu = 1.f; v[2].tv = 1.f;
v[3].x = sx; v[3].y = 0; v[3].tu = 1.f; v[3].tv = 0;
DWORD dwColor = LinearColor(1.f,1.f,1.f,1.f);
int i;
for(i=0;i<4;i++)
{
v[i].color = dwColor;
v[i].z = 0;
v[i].h = 1.0f;
}
CGlobals::GetRenderDevice()->SetTexture(0, m_pMask->GetTexture());
RenderDevice::DrawPrimitiveUP( CGlobals::GetRenderDevice(), RenderDevice::DRAW_PERF_TRIANGLES_UI, D3DPT_TRIANGLESTRIP, 2, v, sizeof(DXUT_SCREEN_VERTEX) );
}
}
//////////////////////////////////////////////////////////////////////////
// Restore state for the normal pipeline
// enable fog
pEffectManager->EnableFog(CGlobals::GetScene()->IsFogEnabled());
// restore old actor position
pActor->PopParam();
// restore transformations
CGlobals::GetProjectionMatrixStack().pop();
CGlobals::GetViewMatrixStack().pop();
CGlobals::GetEffectManager()->UpdateD3DPipelineTransform(true,true, true);
// restore old depth surface
pd3dDevice->SetDepthStencilSurface( pOldZBuffer);
SAFE_RELEASE(pOldZBuffer);
// Restore the old render target: i.e. the backbuffer
HRESULT hr = CGlobals::GetDirectXEngine().SetRenderTarget(0, pOldRenderTarget);
assert(hr == D3D_OK);
// restore render origin
CGlobals::GetScene()->RegenerateRenderOrigin(vOldRenderOrigin);
#ifdef _DEBUG
//SaveToFile("E:\\cavas_obj.png");
#endif
}
void MonsterInfo::ShowNormalMonsterInfo(MonsterData* monster)
{
World.getTextManager().ClearDisplayLines();
World.getTextManager().SetDisplayLine(0, "%s", monster->monster.name.c_str());
World.getTextManager().SetDisplayLine(1, "==============");
World.getTextManager().SetDisplayLine(3, "%s", World.getMonsterManager().getDescription(monster->monster).c_str());
float max_stamina = (float)monster->monster.MaxStamina();
float cur_stamina = (float)monster->monster.stamina;
int state = monster->GetState();
float wounded = (max_stamina - cur_stamina) / max_stamina * 100;
char health[32];
char status[32];
if (wounded < 20)
strcpy(health, "healthy");
else if (wounded < 50)
strcpy(health, "wounded");
else if (wounded < 80)
strcpy(health, "very wounded");
else
strcpy(health, "almost dead");
if (monster->isPlayer())
strcpy(status, "You are ready for anything.");
else
{
switch (state)
{
case normal: strcpy(status, "It has not seen you."); break;
case sentry: strcpy(status, "It appears asleep."); break;
case hostile: strcpy(status, "It is hostile."); break;
case waking: strcpy(status, "It looked annoyed."); break;
case asleep: strcpy(status, "It is asleep."); break;
}
}
if (monster->isPlayer())
World.getTextManager().SetDisplayLine(5, "You look %s.", health);
else
World.getTextManager().SetDisplayLine(5, "It looks %s.", health);
//sprintf(buf,"%s",status);
World.getTextManager().SetDisplayLine(6, "%s", status);
int pSkill = World.getMonsterManager().Player()->Skill();
int tSkill = monster->Skill();
if (tSkill < 6) //0-5
World.getTextManager().SetDisplayLine(7, "Experience: Low");
else if (tSkill < 7) //6
World.getTextManager().SetDisplayLine(7, "Experience: Average");
else if (tSkill < 9) //6-7
World.getTextManager().SetDisplayLine(7, "Experience: Medium");
else if (tSkill < 11) //8-9
World.getTextManager().SetDisplayLine(7, "Experience: High");
else //>=10
World.getTextManager().SetDisplayLine(7, "Experience: Very High");
//inventory
World.getTextManager().SetDisplayLine(9, "Equipment");
ITEMLIST::iterator it;
int i = 10;
for (it = monster->inventory.begin(); it != monster->inventory.end(); it++, i++)
{
#ifdef _DEBUG
World.getTextManager().SetDisplayLine(i, "%s", it->GetName().c_str());
#else
if (it->equipped)
{
World.getTextManager().SetDisplayLine(i, "%s", it->GetName().c_str());
}
else
i--;
#endif
}
i++;
if (monster->monster.effectList.size() > 0)
World.getTextManager().SetDisplayLine(i++, "Active Effects"); i++;
EffectManager effectManager;
EFFECTLIST::iterator eff;
for (eff = monster->monster.effectList.begin(); eff != monster->monster.effectList.end(); eff++, i++)
{
if (eff->strength > 0)
{
std::string eff_msg = effectManager.EffectName(eff->type);
for (int e = 1; e < eff->strength; e++)
eff_msg.append("!");
World.getTextManager().SetDisplayLine(i, (char *)eff_msg.c_str());
}
}
i++;
if (monster->monster.hasResistance() > 0)
World.getTextManager().SetDisplayLine(i++, "Resistances and vulnerabilities"); i++;
BRANDMAP::iterator resist_it;
for (resist_it = monster->monster.resistanceMap.begin(); resist_it != monster->monster.resistanceMap.end(); resist_it++, i++)
{
World.getTextManager().SetDisplayLine(i, " %s (%d)", ResistanceBrands::GetResistanceName(resist_it->first), resist_it->second);
}
World.getTextManager().SetDisplayLine(39, "[x] to Return to looking.");
}
EffectManager::EffectManager(EffectManager& other) : QObject()
{
m_producer = other.producer();
}
void ParaEngine::CMiniSceneGraph::Draw(float fDeltaTime)
{
if(!IsCameraEnabled() || m_pCamera==0)
{
OUTPUT_LOG("warning: one can not call CMiniSceneGraph::draw() function when camera is disabled.\n");
return;
}
bool bRenderToTexture = (GetRenderPipelineOrder() < PIPELINE_UI );
m_sceneState.m_pd3dDevice = CGlobals::GetRenderDevice();
if (IsDirty())
SetDirty(false);
if(bRenderToTexture)
{
if (!Begin())
return;
/** we will allow alpha in render target in case the device support it, if we have fog, the alpha does not take effect. */
DWORD dwColor = 0xffffffff&(DWORD)(IsFogEnabled()? GetFogColor() : GetBackGroundColor());
Clear(LinearColor(dwColor));
}
// animate the camera and push result to transformation stack
m_pCamera->FrameMove(fDeltaTime);
if(IsCameraEnabled() || CGlobals::GetWorldMatrixStack().empty())
CGlobals::GetWorldMatrixStack().push(*CGlobals::GetIdentityMatrix());
CGlobals::GetProjectionMatrixStack().push(*m_pCamera->GetProjMatrix());
CGlobals::GetViewMatrixStack().push(*m_pCamera->GetViewMatrix());
EffectManager* pEffectManager = CGlobals::GetEffectManager();
pEffectManager->UpdateD3DPipelineTransform(true, true, true);
// update the culling planes according to view and projection matrix on top of the global stack
m_pCamera->UpdateFrustum();
m_vRenderOrigin = CGlobals::GetScene()->GetRenderOrigin();
{
EffectTextureStateStack tex_state_(pEffectManager, IsUsePointTexture());
/// the actual draw call is here.
Draw_Internal(fDeltaTime);
}
//////////////////////////////////////////////////////////////////////////
// Restore state for the normal pipeline
if(bRenderToTexture)
{
DoPaint();
End();
}
// restore transformations
if(IsCameraEnabled())
CGlobals::GetWorldMatrixStack().pop();
CGlobals::GetProjectionMatrixStack().pop();
CGlobals::GetViewMatrixStack().pop();
CGlobals::GetEffectManager()->UpdateD3DPipelineTransform(true,true, true);
}
//------------------------------------------------------------------------------------
// The works must to do after rendering the object.
//------------------------------------------------------------------------------------
void Bloom::Render()
{
if (!m_bEnable)
return;
gfx::Renderer* ren = gfx::Renderer::GetSingletonPtr();
EffectManager* emgr = EffectManager::GetSingletonPtr();
ren->Enable(gfx::ERF_2D);
ren->SetTextureParams(gfx::ETP_Anisotropic, 0);
ren->SetTextureParams(gfx::ETP_Point, 6);
m_pImage->SetUV(0.0, 0.0, 1.0, 1.0);
m_pImage->SetSize(ren->GetWindowWidth() / 4, ren->GetWindowHeight() / 4);
// 4X down filter
ren->SetRenderTarget(0, emgr->GetTempRenderTarget(1));
m_pMat->shader->m_pPixelShader = m_pPs4xDownFilter;
ren->SetMaterial(m_pMat);
m_pPs4xDownFilter->SetConstant(m_shPixelCoordsDownFilter, m_fPixelCoordsDownFilter, 32);
m_pImage->m_BackImage = emgr->GetSceneTexture();
m_pImage->Render();
m_pImage->SetUV(0.0, 0.0, 0.25, 0.25);
// Render bright pass in 1/4 size in render target 0
ren->SetRenderTarget(0, emgr->GetTempRenderTarget(0));
m_pMat->shader->m_pPixelShader = m_pPsBrightPass;
ren->SetMaterial(m_pMat);
m_pImage->m_BackImage = emgr->GetTempRenderTarget(1);
m_pImage->Render();
// Render vertical bloom in render target 1
ren->SetRenderTarget(0, emgr->GetTempRenderTarget(1));
m_pMat->shader->m_pPixelShader = m_pPsVerticalBloom;
m_pPsVerticalBloom->SetConstant(m_shPixelKernel, m_fPixelKernelV, 26);
ren->SetMaterial(m_pMat);
m_pImage->m_BackImage = emgr->GetTempRenderTarget(0);
m_pImage->Render();
// Render horizontal bloom in render target 0
ren->SetRenderTarget(0, emgr->GetTempRenderTarget(0));
m_pMat->shader->m_pPixelShader = m_pPsVerticalBloom;
m_pPsVerticalBloom->SetConstant(m_shPixelKernel, m_fPixelKernelH, 26);
ren->SetMaterial(m_pMat);
m_pImage->m_BackImage = emgr->GetTempRenderTarget(1);
m_pImage->Render();
// Render vertical bloom in render target 1
ren->SetRenderTarget(0, emgr->GetTempRenderTarget(1));
m_pMat->shader->m_pPixelShader = m_pPsVerticalBloom;
m_pPsVerticalBloom->SetConstant(m_shPixelKernel, m_fPixelKernelV, 26);
ren->SetMaterial(m_pMat);
m_pImage->m_BackImage = emgr->GetTempRenderTarget(0);
m_pImage->Render();
// Render horizontal bloom in render target 0
ren->SetRenderTarget(0, emgr->GetTempRenderTarget(0));
m_pMat->shader->m_pPixelShader = m_pPsVerticalBloom;
m_pPsVerticalBloom->SetConstant(m_shPixelKernel, m_fPixelKernelH, 26);
ren->SetMaterial(m_pMat);
m_pImage->m_BackImage = emgr->GetTempRenderTarget(1);
m_pImage->Render();
// Render result
ren->SetRenderTarget();
ren->Disable(gfx::ERF_DepthBuffer);
m_pMat->shader->m_pPixelShader = m_pPsCombine;//NULL;//
ren->SetMaterial(m_pMat);
ren->SetTexture(emgr->GetSceneTexture(), 6);
m_pImage->m_BackImage = emgr->GetTempRenderTarget(0);//emgr->GetSceneTexture();//
m_pImage->SetSize(ren->GetWindowWidth(), ren->GetWindowHeight());
ren->SetStencilBuffer(EET_Bloom, 1);
m_pImage->Render();
ren->Enable(gfx::ERF_DepthBuffer);
ren->SetStencilBuffer(EET_Bloom, 2);
ren->Disable(gfx::ERF_2D);
} // Render
HRESULT CGlowEffect::Render(float fGlowThreshold, float fGlowAmount, bool bUseAlpha)
{
//#ifdef _DEBUG
// bUseAlpha = true;
//#endif
HRESULT hr=S_OK;
LPDIRECT3DDEVICE9 pd3dDevice = CGlobals::GetRenderDevice();
// get current render target
m_pBackBuffer = CGlobals::GetDirectXEngine().GetRenderTarget();
if(FAILED(pd3dDevice->GetDepthStencilSurface(&m_pZBuffer)))
return E_FAIL;
if(!m_pBackBuffer || !m_pZBuffer)
return E_FAIL;
// Copy scene to lower resolution render target texture
if( FAILED(hr = pd3dDevice->StretchRect( m_pBackBuffer, NULL, m_pRTHalfSizeSurface, NULL, D3DTEXF_LINEAR )) ) {
OUTPUT_LOG("StretchRect() failed!\r\n");
return hr;
}
EffectManager* pEffectManager = CGlobals::GetEffectManager();
pEffectManager->BeginEffect(TECH_FULL_SCREEN_GLOW);
CEffectFile* pEffectFile = pEffectManager->GetCurrentEffectFile();
if(pEffectFile != 0 && pEffectFile->begin(true, 0))
{
// full screen glow effect is completed in four steps.
assert(pEffectFile->totalPasses() == 4);
mesh_vertex_plain quadVertices[4] = {
{Vector3(-1,-1,0), Vector2(0,1)},
{ Vector3(1, -1, 0), Vector2(1, 1) },
{ Vector3(-1, 1, 0), Vector2(0, 0) },
{ Vector3(1, 1, 0), Vector2(1, 0) },
};
// offset the texture coordinate by half texel in order to match texel to pixel.
// This takes me hours to figure out. :-(
float fhalfTexelWidth = 0.5f/m_glowtextureWidth;
float fhalfTexelHeight = 0.5f/m_glowtextureHeight;
for (int i=0;i<4;++i)
{
quadVertices[i].uv.x += fhalfTexelWidth;
quadVertices[i].uv.y += fhalfTexelHeight;
}
// shader constants
/*
#ifdef TEST_GLOW
static int i=0;
++i;
if(i>30){
fGlowAmount = 1.0f;
fGlowThreshold = 0.f;
if(i>60)
i=0;
}
else
{
fGlowAmount = 0.f;
fGlowThreshold = 1.0f;
}
#endif*/
/*
pEffectFile->setParameter(CEffectFile::k_ConstVector0, (const float*)&Vector4(1/m_glowtextureWidth, 1/m_glowtextureHeight, 0.0f, 0.0f));
LinearColor glowness = pEffectManager->GetGlowness();
glowness.a = fGlowThreshold;
glowness.r *= fGlowAmount;
glowness.g *= fGlowAmount;
glowness.b *= fGlowAmount;
pEffectFile->setParameter(CEffectFile::k_ConstVector1, (const float*)&glowness);
*/
bUseAlpha = true;
if(bUseAlpha)
{
//////////////////////////////////////////////////////////////////////////
// make the glow source. Multiply texture alpha * RGB to get the glow sources
pd3dDevice->SetRenderTarget( 0, m_pRTGlowSourceSurface);
pd3dDevice->SetDepthStencilSurface( NULL );
if(pEffectFile->BeginPass(0))
{
pEffectFile->setTexture(0, m_pRTHalfSizeTexture);
LPD3DXEFFECT fx = pEffectFile->GetDXEffect();
fx->SetFloat(fx->GetParameterByName(NULL,"glowThreshold"),fGlowThreshold);
pEffectFile->CommitChanges();
HRESULT hr = RenderDevice::DrawPrimitiveUP( pd3dDevice, RenderDevice::DRAW_PERF_TRIANGLES_MESH, D3DPT_TRIANGLESTRIP,2,quadVertices,sizeof(mesh_vertex_plain));
pEffectFile->EndPass();
}
}
//////////////////////////////////////////////////////////////////////////
// Blur glow sources in the horizontal axis
pd3dDevice->SetRenderTarget( 0, m_pRTBlurHorizSurface );
pd3dDevice->SetDepthStencilSurface( NULL );
// no need to clear alpha channel?
// pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, 0x00, 1.0f, 0 );
if(pEffectFile->BeginPass(1))
{
SetBlurEffectParameters(1.0f / m_glowtextureWidth,0,fGlowAmount,pEffectFile);
pEffectFile->setTexture(0, m_pRTGlowSourceTexture);
pEffectFile->CommitChanges();
HRESULT hr = RenderDevice::DrawPrimitiveUP( pd3dDevice, RenderDevice::DRAW_PERF_TRIANGLES_MESH, D3DPT_TRIANGLESTRIP,2,quadVertices,sizeof(mesh_vertex_plain));
pEffectFile->EndPass();
}
// set texture 0 to NULL so same texture is never simultaneously a source and render target
pEffectFile->setTexture( 0, (LPDIRECT3DTEXTURE9)NULL );
//////////////////////////////////////////////////////////////////////////
// Blur the horizontal blur in the vertical direction
pd3dDevice->SetRenderTarget( 0, m_pRTBlurVertSurface );
pd3dDevice->SetDepthStencilSurface( NULL );
// no need to clear alpha channel?
// pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, 0x00, 1.0f, 0 );
//fGlowAmount = 2;
if(pEffectFile->BeginPass(1))
{
//pEffectFile->setTexture( 1, m_pRTBlurHorizTexture );
SetBlurEffectParameters(0,1.0f / m_glowtextureHeight,fGlowAmount,pEffectFile);
pEffectFile->setTexture(0, m_pRTBlurHorizTexture ); //editor here!!!
pEffectFile->CommitChanges();
HRESULT hr = RenderDevice::DrawPrimitiveUP( pd3dDevice, RenderDevice::DRAW_PERF_TRIANGLES_MESH, D3DPT_TRIANGLESTRIP,2,quadVertices,sizeof(mesh_vertex_plain));
pEffectFile->EndPass();
}
// Set all textures to NULL to prevent RTT being bound as source and destination at the same time,
pEffectFile->setTexture( 0,(LPDIRECT3DTEXTURE9)NULL );
//////////////////////////////////////////////////////////////////////////
// Add the final blur image to the back buffer
pd3dDevice->SetRenderTarget( 0, m_pBackBuffer);
pd3dDevice->SetDepthStencilSurface( NULL );
// no need to clear alpha channel?
// pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, 0x00, 1.0f, 0 );
for (int i=0;i<4;++i)
{
quadVertices[i].uv.x -= fhalfTexelWidth * 0.5f;
quadVertices[i].uv.y -= fhalfTexelHeight * 0.5f;
}
if(pEffectFile->BeginPass(3))
{
pEffectFile->setTexture(0, m_pRTHalfSizeTexture );
pEffectFile->setTexture(1,m_pRTBlurVertTexture);
Vector4 glowParam = pEffectManager->GetGlowness();
LPD3DXEFFECT fx = pEffectFile->GetDXEffect();
fx->SetVector(fx->GetParameterByName(NULL,"glowParams"), (const DeviceVector4*)&glowParam);
pEffectFile->CommitChanges();
HRESULT hr = RenderDevice::DrawPrimitiveUP( pd3dDevice, RenderDevice::DRAW_PERF_TRIANGLES_MESH, D3DPT_TRIANGLESTRIP,2,quadVertices,sizeof(mesh_vertex_plain));
pEffectFile->EndPass();
pEffectFile->setTexture( 0, (LPDIRECT3DTEXTURE9)NULL );
pEffectFile->setTexture(1,(LPDIRECT3DTEXTURE9)NULL);
}
// restore depth stencil buffer
pd3dDevice->SetDepthStencilSurface( m_pZBuffer );
pEffectFile->end();
}
else
{
CGlobals::GetScene()->EnableFullScreenGlow(false);
//Glow effect will not be load when graphics setting set to middle
//so we just disable this warnning
//OUTPUT_LOG("can not set full screen glow effect error \r\n");
}
SAFE_RELEASE(m_pZBuffer);
return hr;
}
int run()
{
const unsigned int nMaxEffectUpdateCnt = _nHartBeatFreq / _nEffectUpdateFreq;
unsigned int nEffectUpdateCnt = 0;
// Initailize app. if not already done, and exit if something went wrong.
if (!_bIsInitialized)
initialize();
if (!_bIsInitialized)
return _nStatus;
try
{
//Main polling loop
while(!_bMustStop)
{
// This fires off buffered events for keyboards
_pKeyboard->capture();
// This fires off buffered events for each joystick we have
_pJoystickMgr->captureEvents();
// Update currently selected effects if time has come to.
if (!nEffectUpdateCnt)
{
_pEffectMgr->updateActiveEffects();
nEffectUpdateCnt = nMaxEffectUpdateCnt;
}
else
nEffectUpdateCnt--;
// Update state line.
cout << "\r" << _pJoystickMgr->toString() << " " << _pEffectMgr->toString()
<< " ";
//Throttle down CPU usage & handle OS events
#if defined OIS_WIN32_PLATFORM
Sleep( (DWORD)(1000.0/_nHartBeatFreq) );
MSG msg;
while( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
#elif defined OIS_LINUX_PLATFORM
checkX11Events();
usleep(1000000.0/_nHartBeatFreq);
#endif
}
}
catch( const Exception &ex )
{
#if defined OIS_WIN32_PLATFORM
MessageBox(0, ex.eText, "Exception Raised!", MB_OK);
#else
cout << endl << "OIS Exception Caught!" << endl
<< "\t" << ex.eText << "[Line " << ex.eLine << " in " << ex.eFile << "]" << endl;
#endif
}
terminate();
return _nStatus;
}
HRESULT ParaEngine::CLightObject::RenderMesh(SceneState * sceneState)
{
if (!m_pAnimatedMesh)
return E_FAIL;
if (GetPrimaryTechniqueHandle() < 0)
{
// try loading the asset if it has not been done before.
m_pAnimatedMesh->LoadAsset();
if (m_pAnimatedMesh->IsLoaded())
{
SetPrimaryTechniqueHandle(m_pAnimatedMesh->GetPrimaryTechniqueHandle());
UpdateGeometry();
}
return E_FAIL;
}
if (!CGlobals::GetEffectManager()->IsCurrentEffectValid())
{
return E_FAIL;
}
CParaXModel* pModel = m_pAnimatedMesh->GetModel(0);
if (pModel == NULL)
return E_FAIL;
sceneState->SetCurrentSceneObject(this);
SetFrameNumber(sceneState->m_nRenderCount);
// get world transform matrix
Matrix4 mxWorld;
GetRenderMatrix(mxWorld);
RenderDevicePtr pd3dDevice = sceneState->m_pd3dDevice;
EffectManager* pEffectManager = CGlobals::GetEffectManager();
pEffectManager->applyObjectLocalLighting(this);
CEffectFile* pEffectFile = pEffectManager->GetCurrentEffectFile();
CGlobals::GetWorldMatrixStack().push(mxWorld);
if (pEffectFile == 0)
{
// TODO: Fixed Function.
}
else
{
// apply block space lighting for object whose size is comparable to a single block size
BlockWorldClient* pBlockWorldClient = BlockWorldClient::GetInstance();
if (pBlockWorldClient && pBlockWorldClient->IsInBlockWorld())
{
uint8_t brightness[2];
Uint16x3 blockId_ws(0, 0, 0);
Vector3 vPos = GetPosition();
BlockCommon::ConvertToBlockIndex(vPos.x, vPos.y + 0.1f, vPos.z, blockId_ws.x, blockId_ws.y, blockId_ws.z);
float fLightness;
pBlockWorldClient->GetBlockMeshBrightness(blockId_ws, brightness);
// block light
float fBlockLightness = Math::Max(pBlockWorldClient->GetLightBrightnessFloat(brightness[0]), 0.1f);
sceneState->GetCurrentLightStrength().y = fBlockLightness;
// sun light
fLightness = Math::Max(pBlockWorldClient->GetLightBrightnessFloat(brightness[1]), 0.1f);
sceneState->GetCurrentLightStrength().x = fLightness;
fLightness *= pBlockWorldClient->GetSunIntensity();
fLightness = Math::Max(fLightness, fBlockLightness);
sceneState->GetLocalMaterial().Ambient = (LinearColor(fLightness*0.7f, fLightness*0.7f, fLightness*0.7f, 1.f));
sceneState->GetLocalMaterial().Diffuse = (LinearColor(fLightness*0.4f, fLightness*0.4f, fLightness*0.4f, 1.f));
sceneState->EnableLocalMaterial(true);
}
// just a single standing animation is supported now and looped.
if (!m_CurrentAnim.IsValid())
m_CurrentAnim = pModel->GetAnimIndexByID(0);
if (m_CurrentAnim.IsValid())
{
int nAnimLength = std::max(1, m_CurrentAnim.nEndFrame - m_CurrentAnim.nStartFrame);
int nToDoFrame = (m_CurrentAnim.nCurrentFrame + (int)(sceneState->dTimeDelta * 1000)) % nAnimLength;
m_CurrentAnim.nCurrentFrame = nToDoFrame;
}
pModel->m_CurrentAnim = m_CurrentAnim;
pModel->m_NextAnim.nIndex = 0;
pModel->m_BlendingAnim.MakeInvalid();
pModel->blendingFactor = 0;
pModel->animate(sceneState, NULL);
// force CParaXModel::BMAX_MODEL?
pModel->draw(sceneState, NULL);
}
CGlobals::GetWorldMatrixStack().pop();
return S_OK;
}
