code stringlengths 1 2.06M | language stringclasses 1 value |
|---|---|
#include "../global_def.h"
#include "IFCommon.h"
int CIFLoginWin::ChangeLoginStep( int step )
{
if( step == m_loginStep ) return 0;
int i;
int oldLoginStep = m_loginStep;
int stepFlag[6] = { 0, 0, 0, 0, 0 , 0};
stepFlag[step] = 1;
#if defined (_GTH_TERRA_VERSION) || (_GTH_MALAYSIA_CHN_VERSION)
stepFlag[0] = 0;
#endif
m_login->Enable( stepFlag[0] );
m_loginTitleBar->Enable( stepFlag[0] );
m_loginTitleBottom->Enable( stepFlag[0] );
m_loginBar->Enable( stepFlag[0] );
m_loginLeftBar->Enable( stepFlag[0] );
m_loginRightBar->Enable( stepFlag[0] );
m_loginIDBar->Enable( stepFlag[0] );
m_loginPasswordBar->Enable( stepFlag[0] );
m_loginOkBtn->Enable( stepFlag[0] );
m_loginCancelBtn->Enable( stepFlag[0] );
#ifdef _GTH_ENABLE_GOODNOTICE
m_loginNotice->Enable(stepFlag[LOGIN_STATE_NOTICE]);
m_cNoticeOkBtn->Enable(stepFlag[LOGIN_STATE_NOTICE]);
#endif
for( i = 0; i < MAX_COUNT_IF_LOGIN_WIN_SERVER_BTN; i ++ )
m_serverBtn[i]->Enable( false );
m_serverOkBtn->Enable( false );
m_serverCancelBtn->Enable( false );
m_cselInfo->Enable( false );
m_cselInfoTitleBar->Enable( stepFlag[2] );
m_cselInfoTitleBottom->Enable( stepFlag[2] );
m_cselInfoBar->Enable( stepFlag[2] );
m_cselInfoGenBar->Enable( stepFlag[2] );
m_cselInfoGenIcon0->Enable( stepFlag[2] );
m_cselInfoGenIcon1->Enable( stepFlag[2] );
m_cselInfoGenIcon2->Enable( stepFlag[2] );
m_cselInfoGenIcon3->Enable( stepFlag[2] );
m_cselExitBtn->Enable( false );
m_cselOkBtn->Enable( false );
m_cselBackBtn->Enable( false );
m_cselDeleteBtn->Enable( false );
m_cselMakeBtn->Enable( false );
m_DifferentCharBtn->Enable(false);
#ifdef _GTH_FLAG_RELOGIN
m_cReLoginBtn->Enable(false);
#endif
m_cmakeInfo->Enable( false );
m_cmakeInfoTitleBar->Enable( stepFlag[3] );
m_cmakeInfoTitleBottom->Enable( stepFlag[3] );
m_cmakeInfoBar->Enable( stepFlag[3] );
m_cmake->Enable( stepFlag[3] );
m_cmakeTitleBar->Enable( stepFlag[3] );
m_cmakeTitleBottom->Enable( stepFlag[3] );
m_cmakeBar->Enable( stepFlag[3] );
m_cmakeNameIcon->Enable( stepFlag[3] );
m_cmakeNameBar->Enable( stepFlag[3] );
m_cmakeFaceIcon->Enable( stepFlag[3] );
m_cmakeFaceBar->Enable( stepFlag[3] );
m_cmakeHairIcon->Enable( stepFlag[3] );
m_cmakeHairBar->Enable( stepFlag[3] );
m_cmakeStatBar->Enable( stepFlag[3] );
m_cmakeStatLine->Enable( stepFlag[3] );
m_cmakeForceIcon->Enable( stepFlag[3] );
m_cmakeForceBar->Enable( stepFlag[3] );
m_cmakeSoulIcon->Enable( stepFlag[3] );
m_cmakeSoulBar->Enable( stepFlag[3] );
m_cmakeAgiIcon->Enable( stepFlag[3] );
m_cmakeAgiBar->Enable( stepFlag[3] );
m_cmakeVitIcon->Enable( stepFlag[3] );
m_cmakeVitBar->Enable( stepFlag[3] );
m_cmakeFacePrevBtn->Enable( stepFlag[3] );
m_cmakeFaceNextBtn->Enable( stepFlag[3] );
m_cmakeHairPrevBtn->Enable( stepFlag[3] );
m_cmakeHairNextBtn->Enable( stepFlag[3] );
m_cmakeForceUpBtn->Enable( stepFlag[3] );
m_cmakeForceDnBtn->Enable( stepFlag[3] );
m_cmakeSoulUpBtn->Enable( stepFlag[3] );
m_cmakeSoulDnBtn->Enable( stepFlag[3] );
m_cmakeAgiUpBtn->Enable( stepFlag[3] );
m_cmakeAgiDnBtn->Enable( stepFlag[3] );
m_cmakeVitUpBtn->Enable( stepFlag[3] );;
m_cmakeVitDnBtn->Enable( stepFlag[3] );
m_cmakeOkBtn->Enable( stepFlag[3] );
m_cmakeCancelBtn->Enable( stepFlag[3] );
m_cmakePrevBtn->Enable( false );
m_cmakeNextBtn->Enable( false );
switch( m_loginStep )
{
case LOGIN_STATE_IDPW :
{
g_chatManager->InitInputStr( 0 );
g_chatManager->InitInputStr( 1 );
g_chatManager->SetInputState( 0, -1 );
g_chatManager->SetInputState( 1, -1 );
m_selectedCharacter = NULL;
if ( g_cgv.state == CLIENT_LOGIN_PROCESS )
g_ifMng->m_ServerListWin->Enable(TRUE);
}
break;
case LOGIN_STATE_SELECT_SERVER :
{
}
break;
case LOGIN_STATE_SELECT_CHARACTER :
{
}
break;
case LOGIN_STATE_CREATE_CHARACTER :
{
g_chatManager->SetInputState( 0, -1 );
}
break;
}
m_loginStep = step;
switch( m_loginStep )
{
case LOGIN_STATE_IDPW :
{
if( stepFlag[0] )
{
int cx, cy;
cx = m_textCtl[IT_LOGIN_WIN_ID_U]->GetXPos();
cy = m_textCtl[IT_LOGIN_WIN_ID_U]->GetYPos();
g_chatManager->SetInput( cx, cy, 12, 12, 0, 1, 90 );
cx = m_textCtl[IT_LOGIN_WIN_PASSWORD_U]->GetXPos();
cy = m_textCtl[IT_LOGIN_WIN_PASSWORD_U]->GetYPos();
g_chatManager->SetInput( cx, cy, 12, 12, 1, 2, 90 );
g_cgv.enableChat = true;
g_chatManager->ChangeInputMessage( INPUT_INDEX_DIALOGBOX );
}
}
break;
case LOGIN_STATE_SELECT_SERVER :
{
}
break;
case LOGIN_STATE_SELECT_CHARACTER :
{
}
break;
case LOGIN_STATE_CREATE_CHARACTER :
{
int cx, cy;
cx = m_textCtl[IT_CHARMAKE_WIN_NAME_U]->GetXPos();
cy = m_textCtl[IT_CHARMAKE_WIN_NAME_U]->GetYPos();
g_chatManager->SetInput( cx, cy, NAMESTRING - 2, NAMESTRING - 2, INPUT_INDEX_DIALOGBOX, 1 );
g_cgv.enableChat = true;
g_chatManager->ChangeInputMessage( INPUT_INDEX_DIALOGBOX );
}
}
return( oldLoginStep );
}
#ifdef _TERRA
#include "..\Terra ICT\CTerraCtrl.h"
extern CTerraCtrl gcTerraCtrl;
#endif
void CIFLoginWin::RequestLogin()
{
if ( g_cgv.restartState == RESTART_NONE )
{
strcpy( g_cgv.clientID, g_chatManager->GetInputStr( 0 ) );
strcpy( g_cgv.clientPassword, g_chatManager->GetInputStr( 1 ) );
}
#if defined(_GTH_ONLINE_VERSION)
#if defined(_TERRA)
gcTerraCtrl.GTH_SendMessage_RequestLogin();
#else
GTH_SendMessage_RequestLogin( g_cgv.clientID, g_cgv.clientPassword );
#endif
#endif
}
void CIFLoginWin::MakeServerList()
{
DWORD color;
char szTemp[256], serverName[256];
int x, y;
if( g_cgv.restartState == RESTART_CHARACTER )
{
m_cameraStep = 0;
m_selectedCharacter = NULL;
RequestGameData();
return;
}
else if( g_cgv.restartState == RESTART_SERVER )
{
m_cameraStep = 0;
m_selectedCharacter = NULL;
}
#if defined (_GTH_CHINESE_VERSION) || (_GTH_MALAYSIA_CHN_VERSION )
x = g_ifMng->m_clientWidth / 2 - m_serverBtn[0]->m_info[0].sizeX;
y = g_ifMng->m_clientHeight / 2 - ( m_serverBtn[0]->m_info[0].sizeY * ( MAX_SERVER_GROUP / 2 ) ) / 2;
#else
x = g_ifMng->m_clientWidth / 2 - m_serverBtn[0]->m_info[0].sizeX / 2;
y = g_ifMng->m_clientHeight / 2 - ( m_serverBtn[0]->m_info[0].sizeY * ( MAX_SERVER_GROUP ) ) / 2;
#endif
for( int i = 0; i < MAX_SERVER_GROUP; i ++ )
{
strcpy( serverName, g_cgv.serverGroup[i].name );
if ( g_cgv.serverGroup[i].active )
{
if( g_cgv.serverGroup[i].access )
{
if( g_cgv.serverGroup[i].clientNumber < 100 ) strcpy( szTemp, "(Good)" );
else if( g_cgv.serverGroup[i].clientNumber < 200 ) strcpy( szTemp, "(Normal)" );
else if( g_cgv.serverGroup[i].clientNumber < 500 ) strcpy( szTemp, "(Busy)" );
else strcpy( szTemp, "(Very Busy)" );
color = 0xffffffff;
m_serverBtn[i]->SetButtonState( IF_BTN_TYPE_ENABLE );
}
else
{
sprintf( szTemp, "(%s)", g_LPACK.GetMassage(0,346) );
color = 0xff808080;
m_serverBtn[i]->SetButtonState( IF_BTN_TYPE_DISABLE );
}
}
else
{
sprintf( szTemp, "(%s)", g_LPACK.GetMassage(0,346) );
color = 0xff808080;
m_serverBtn[i]->SetButtonState( IF_BTN_TYPE_DISABLE );
}
strcat( serverName, szTemp );
m_serverBtn[i]->SetButtonText( serverName, color );
#if defined (_GTH_CHINESE_VERSION) || (_GTH_MALAYSIA_CHN_VERSION )
m_serverBtn[i]->UpdateClientPosition( x + ( i % 2 ) * m_serverBtn[0]->m_info[0].sizeX, y + ( i / 2 ) * m_serverBtn[0]->m_info[0].sizeY );
#else
m_serverBtn[i]->UpdateClientPosition( x, y + i * m_serverBtn[0]->m_info[0].sizeY );
#endif
m_serverBtn[i]->Enable( true );
}
}
void CIFLoginWin::MakeMasterServerGroupList()
{
DWORD color = 0xffffffff;
char serverName[256];
int x, y;
x = g_ifMng->m_clientWidth / 2 - m_serverBtn[0]->m_info[0].sizeX / 2;
y = g_ifMng->m_clientHeight / 2 - ( m_serverBtn[0]->m_info[0].sizeY * ( g_cgv.masterServerGroupNumber ) ) / 2;
for( int i = 0; i < g_cgv.masterServerGroupNumber; i ++ )
{
strcpy( serverName, g_cgv.masterServerGroupInfo[i].masterServerGroupName );
m_serverBtn[i]->SetButtonState( IF_BTN_TYPE_ENABLE );
m_serverBtn[i]->SetButtonText( serverName, color );
m_serverBtn[i]->UpdateClientPosition( x, y + i * m_serverBtn[0]->m_info[0].sizeY );
m_serverBtn[i]->Enable( true );
}
}
void CIFLoginWin::RequestGameData()
{
#ifdef _GTH_ONLINE_VERSION
GTH_SendMessage_RequestGameData();
#endif
}
void CIFLoginWin::RequestMakeCharacter()
{
m_makeFlag = true;
m_cameraStep = 1;
m_curSelectedMakeCharacter = 0;
m_cameraStepFlag = true;
}
void CIFLoginWin::RequestCheckCharacterName()
{
charEditData_t *pChar = &m_makeCharData[m_curSelectedMakeCharacter];
char substr[2];
strcpy( pChar->name, g_chatManager->GetInputStr( 0 ) );
if( pChar->name[0] == 0 )
{
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(0,95), 1, IF_MESSAGE_NONE );
return;
}
if ( strstr( pChar->name, g_LPACK.GetMassage(0,96)) != NULL )
{
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(0,97), 1, IF_MESSAGE_NONE );
return;
}
if ( strstr( pChar->name, g_LPACK.GetMassage(0,97)) != NULL )
{
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(0,98), 1, IF_MESSAGE_NONE );
return;
}
if ( strstr( pChar->name, g_LPACK.GetMassage(0,99)) != NULL )
{
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(0,100), 1, IF_MESSAGE_NONE );
return;
}
if ( strstr( pChar->name, "gM") != NULL )
{
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(0,343), 1, IF_MESSAGE_NONE );
return;
}
if ( strstr( pChar->name, "Gm") != NULL )
{
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(0,398), 1, IF_MESSAGE_NONE );
return;
}
if ( !g_chatManager->IsVaildString( pChar->name ) )
{
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage( 0, 554 ), 1, IF_MESSAGE_NONE );
return;
}
for ( int i = 0; i < 128; i++)
{
if ( i == 0 ) continue;
if (i > 47 && i < 58) continue;
if (i > 64 && i < 91) continue;
if (i > 96 && i < 123) continue;
sprintf(substr, "%c", i);
if ( strstr( pChar->name, substr) != NULL )
{
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(0,399), 1, IF_MESSAGE_NONE );
return;
}
}
GTH_SendMessage_RequestCheckCharacterName( pChar->name );
}
void CIFLoginWin::RequestServerAddress()
{
if( m_selectedCharacter == NULL ) return;
if( m_selectedCharacter->entityType == ENTITY_NPC ) return;
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(0,113), MSG_BUTTONTYPE_NONE );
#ifdef _GTH_ONLINE_VERSION
GTH_SendMessage_RequestGameServerAddr();
#else
GTH_ProcessMessage_ReplyServerAddress();
#endif
}
void CIFLoginWin::SetCharacterInfo()
{
extern Fx_CHARACTER_t *g_mouseSelectedCharacter;
myCharacterInfo_t *selectedChar;
int idx;
char szTemp[256];
if( g_mouseSelectedCharacter == NULL && m_selectedCharacter == NULL )
{
m_cselInfo->Enable( false );
return;
}
else if( g_mouseSelectedCharacter != NULL && m_selectedCharacter == NULL )
{
idx = g_mouseSelectedCharacter->ID;
if ( g_cgv.characterSlotMode == globalVariable_t::CharacterSlotMode::BACK)
idx += 3;
if( idx >= MAX_SAVED_DATA )
return;
g_ifMng->m_iPos[IF_CHARINFO_WIN].clientX = g_ifMng->m_clientWidth / 2 - g_ifMng->m_iPos[IF_CHARINFO_WIN].sizeX / 2;
g_ifMng->m_iPos[IF_CHARINFO_WIN].clientY = 0;
UpdateControl();
}
else if( m_selectedCharacter != NULL )
{
idx = m_selectedCharacter->ID;
if ( g_cgv.characterSlotMode == globalVariable_t::CharacterSlotMode::BACK)
idx += 3;
if( idx >= MAX_SAVED_DATA )
return;
g_ifMng->m_iPos[IF_CHARINFO_WIN].clientX = 0;
g_ifMng->m_iPos[IF_CHARINFO_WIN].clientY = 0;
UpdateControl();
}
selectedChar = &g_cgv.savedData[idx];
if( selectedChar->characterID < 0 )
{
m_cselInfo->Enable( false );
return;
}
m_cselInfo->Enable( true );
m_textCtl[IT_CHARINFO_WIN_CHARINFO]->SetText( g_LPACK.GetMassage( 0, 506 ) );
sprintf( szTemp, g_LPACK.GetMassage( 0, 555 ), selectedChar->name );
m_textCtl[IT_CHARINFO_WIN_NAME_U]->SetText( szTemp );
sprintf( szTemp, g_LPACK.GetMassage( 0, 556 ), selectedChar->level, selectedChar->genLevel );
m_textCtl[IT_CHARINFO_WIN_LEVEL_U]->SetText( szTemp );
sprintf( szTemp, g_LPACK.GetMassage( 0, 557 ), selectedChar->rank );
m_textCtl[IT_CHARINFO_WIN_RANK_U]->SetText( szTemp );
sprintf( szTemp, g_LPACK.GetMassage( 0, 558 ),
g_LPACK.GetMassage( LPACK_TYPE_ETC, CLPack_Etc::LPACK_ETCTYPE_GEN_ATTRIBUTE, selectedChar->pcClass ) );
m_textCtl[IT_CHARINFO_WIN_CLASS_U]->SetText( szTemp );
sprintf( szTemp, g_LPACK.GetMassage( 0, 559 ), g_LPACK.GetMassage( LPACK_TYPE_ETC, CLPack_Etc::LPACK_ETCTYPE_PC_JOB, selectedChar->pcJob ) );
m_textCtl[IT_CHARINFO_WIN_GEN_BAR]->SetText( szTemp );
m_textCtl[IT_CHARINFO_WIN_GEN_ICON_0_U]->SetText( g_LPACK.GetMassage( 0, 464 ) );
m_textCtl[IT_CHARINFO_WIN_GEN_ICON_1_U]->SetText( g_LPACK.GetMassage( 0, 464 ) );
m_textCtl[IT_CHARINFO_WIN_GEN_ICON_2_U]->SetText( g_LPACK.GetMassage( 0, 464 ) );
m_textCtl[IT_CHARINFO_WIN_GEN_ICON_3_U]->SetText( g_LPACK.GetMassage( 0, 464 ) );
if( CheckAvailableGenCapability( selectedChar, J_MENTALITY ) )
{
strcpy( szTemp, g_ifMng->GetNumberString( selectedChar->genCapability[0] ) );
m_cselInfoGenIcon0->ChangeControlTexInfo( IF_CHAR_WIN_PGEN_MARK_0_0 );
}
else
{
strcpy( szTemp, g_LPACK.GetMassage( 0, 465 ) );
m_cselInfoGenIcon0->ChangeControlTexInfo( IF_CHAR_WIN_PGEN_MARK_0_0 + 1 );
}
m_textCtl[IT_CHARINFO_WIN_GENCAP_0_U]->SetText( szTemp );
if( CheckAvailableGenCapability( selectedChar, J_WIND ) )
{
strcpy( szTemp, g_ifMng->GetNumberString( selectedChar->genCapability[1] ) );
m_cselInfoGenIcon1->ChangeControlTexInfo( IF_CHAR_WIN_PGEN_MARK_1_0 );
}
else
{
strcpy( szTemp, g_LPACK.GetMassage( 0, 465 ) );
m_cselInfoGenIcon1->ChangeControlTexInfo( IF_CHAR_WIN_PGEN_MARK_1_0 + 1 );
}
m_textCtl[IT_CHARINFO_WIN_GENCAP_1_U]->SetText( szTemp );
if( CheckAvailableGenCapability( selectedChar, J_WATER ) )
{
strcpy( szTemp, g_ifMng->GetNumberString( selectedChar->genCapability[2] ) );
m_cselInfoGenIcon2->ChangeControlTexInfo( IF_CHAR_WIN_PGEN_MARK_2_0 );
}
else
{
strcpy( szTemp, g_LPACK.GetMassage( 0, 465 ) );
m_cselInfoGenIcon2->ChangeControlTexInfo( IF_CHAR_WIN_PGEN_MARK_2_0 + 1 );
}
m_textCtl[IT_CHARINFO_WIN_GENCAP_2_U]->SetText( szTemp );
if( CheckAvailableGenCapability( selectedChar, J_EARTH ) )
{
strcpy( szTemp, g_ifMng->GetNumberString( selectedChar->genCapability[3] ) );
m_cselInfoGenIcon3->ChangeControlTexInfo( IF_CHAR_WIN_PGEN_MARK_3_0 );
}
else
{
strcpy( szTemp, g_LPACK.GetMassage( 0, 465 ) );
m_cselInfoGenIcon3->ChangeControlTexInfo( IF_CHAR_WIN_PGEN_MARK_3_0 + 1 );
}
m_textCtl[IT_CHARINFO_WIN_GENCAP_3_U]->SetText( szTemp );
} | C++ |
#if !defined(AFX_IFMANAGER_H__86A8040D_25CC_469E_A444_A21402266A97__INCLUDED_)
#define AFX_IFMANAGER_H__86A8040D_25CC_469E_A444_A21402266A97__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "IFCommon.h"
class CIFManager
{
public:
int m_controlFlag;
IFControlInfo_t *m_iPos;
IFControlInfo_t *m_iBackPos;
IFTextureInfo_t m_texInfo[MAX_COUNT_IF_TEXTURE];
int m_numTexInfo;
int m_clientWidth;
int m_clientHeight;
char m_msgTitleStr[256];
char m_msgStr[256];
int m_msgType;
float m_msgTime;
float m_msgWaitTime;
int m_renderLoadingFlag;
int m_changeStateFlag;
int m_renderFlag;
int m_saveBindingIdx;
int m_saveBindingCost;
char m_rolloverText[2048];
int m_rolloverAddFirstFlag;
int m_mapType;
vec3_t m_itemDropPos;
float m_noticeTime;
char m_noticeMsg[256];
DWORD m_noticeColor;
BOOL m_GmNotice;
CD3DTextureMng *m_texMng;
CFileMng *m_fileMng;
CScript *m_script;
LPDIRECT3DDEVICE8 m_pd3dDevice;
CIFControl *m_jystechLogo;
CIFControl *m_malLogo;
BYTE m_bLogoStep;
CIFControl *m_startLogo;
CIFControl *m_loadingLogo;
CIFMsgWin *m_msgWin;
CIFLoginWin *m_loginWin;
CIFNameWin *m_nameWin;
CIFCharWin *m_charWin;
CIFItemWin *m_itemWin;
CIFMenuWin *m_menuWin;
CIFChatWin *m_chatWin;
CIFStoreWin *m_storeWin;
CIFRolloverWin *m_rolloverWin;
CIFSkillWin *m_skillWin;
CIFQuestWin *m_questWin;
CIFOptionWin *m_optionWin;
CIFTradeWin *m_tradeWin;
CIFStackWin *m_stackWin;
CIFDlgWin *m_dlgWin;
CIFChatOptionWin *m_chatOptionWin;
CIFWorldChatWin *m_worldChatWin;
CIFLearnWin *m_learnWin;
CIFDepotWin *m_depotWin;
CIFHotWin *m_hotWin;
CIFHelpWin *m_helpWin;
CIFPartyWin *m_partyWin;
CIFGmWin *m_gmWin;
CIFPrecocityWin *m_precocityWin;
CIFCraftWin *m_craftWin;
CIFEventCraftWin *m_EventCraftWin;
CIFUpgradeWin *m_upgradeWin;
CIFMapWin *m_mapWin;
CIFMiniMapWin *m_miniMapWin;
CIFBoothWin *m_boothWin;
CIFTutorialWin *m_tutorialWin;
CIFTipWin *m_tipWin;
CIFSettingWin *m_settingWin;
CIFCraftHelpWin *m_craftHelpWin;
CIFCommunityWin *m_communityWin;
CIFMailWin *m_mailWin;
CIFMailEditWin *m_mailEditWin;
CIFFriendWin *m_friendWin;
CIFQuestScrollWin *m_questscrollWin;
CIFGuildWin *m_guildWin;
CIFGuildAuthWin *m_guildAuthWin;
CIFGuildPvPWin *m_guildPvpWin;
CIFGuildArenaWin *m_guildArenaWin;
CIFGuild_battle_info_win *m_guildArenaInfoWin;
CIFAutoQuestWin *m_autoQuestWin;
CIFNpcInvWin *m_npcInvWin;
CIFSurgeryWin *m_surgeryWin;
CIFBattleTicketWin *m_battleTicketWin;
CIFShareWin *m_shareWin;
CIFTournamentWin *m_tournamentWin;
CIFPrizeWin *m_prizeWin;
CIFGolryunInfoWin *m_golryunInfoWin;
CIFObserverMenuWin *m_observerMenuWin;
CIFObserverInfoWin *m_observerInfoWin;
CIFTournamentMiniWin *m_tournamentMiniWin;
CIFIconCtl *m_iconCtl;
CIFMouseCursor *m_cursor;
CIFNumCtl *m_numCtl;
CIFWindow *m_winControl[NUM_IF_WINDOW_TYPE];
CIFPMManager *m_guildMarkMng;
CIFGonryunBattlePractice *m_pgonryunBattlePractice;
CIFBattingWindow *m_pgonryunBattleBattingwindow;
CIFGonryunBattleProgressInfo *m_pGonryunBattleProgressInfo;
char m_tempString[CHATSTRING];
CIFPostWin *m_PostWin;
CIFMailBoxWin *m_mailBoxWin;
CIFWorld_ChangeWin *m_WorldChangeWin;
CIFHelperWin *m_HelperWin;
CIFGiftCardWin *m_GiftCardWin;
CIFServer_ListWin *m_ServerListWin;
CIFCashMallItem *m_CashMallItem;
CItem_ScrollWin *m_Item_ScrollWin;
CIFDanWarRequestWin *m_DanWarRequestWin;
CIFDanWarBattleWin *m_DanWarBattleWin;
BOOL m_Visible;
BOOL m_VisibleName;
CIFManager();
virtual ~CIFManager();
int LoadConfig( char *filename );
int GetInterfacePositionID( char* posID );
void GetInterfacePositionWidth( int id, int &x, int &size );
void GetInterfacePositionHeight( int id, int &y, int &size );
int GetInterfaceParentPositionID( char* id );
void SetTexManager ( CD3DTextureMng *texMng );
void SetFileManager ( CFileMng *fileMng );
void SetScript ( CScript *script );
void SetDevice ( LPDIRECT3DDEVICE8 device );
void SetRenderState();
void UpdateTextureID( int group );
void AddTextureToManager( int group );
void FinalCleanup();
void InitDeviceObjects();
void InvalidateDeviceObjects();
void RestoreDeviceObjects();
void UpdateAllBuffer();
void PrepareAllControl( int width, int height );
void UpdateAllControl();
void ChangeResolution( int in_width, int in_height );
int ProcessInterface();
void PrepareRender();
void Render();
int ProcessSelection();
void ProcessCursor();
void RestartInterface( int type );
int CheckConditionalWindow();
char* GetNumberString( int number );
char* GetTimeString( int sec );
void InitSoundVolume();
void InitRolloverText();
void AddRolloverText( char *str, int colorIdx = -1, int lineFeed = true );
void MakeRolloverText( int x, int y, int forcedWinFlag = true, int sx = -1, int sy = -1, int arrangeType = CHAT_ARRANGE_CENTER );
void MakeItemRollover( item_t *item, int numFlag = false );
void MakeActionRollover( int idx );
void MakeSkillRollover( int idx, int tableFlag );
void MakeSkillRollover_GetValue(int _MySkillIndex,int skillTableIdx,SKILL_GEN_LEVEL &skillLevel);
void MakeHotRollover( int idx );
void MakeItemOptionRender( item_t *item );
char* GetItemRequireJobText( itemTable_t *pItem );
char* GetItemRequireStatText( itemTable_t *pItem );
char* GetItemAvailableOnText( int optionIdx );
void AddFocus( CIFWindow *pCtl );
int SetFocus( CIFWindow *pCtl );
CIFWindow* GetFocus() { return( m_winControl[0] ); }
int ProcessIFKeyState();
void SetVAMessage(char* title, LPCTSTR lpszFormat, ...);
bool SetMessage( char* title, char* msg, int button = MSG_BUTTONTYPE_OK, int type = IF_MESSAGE_NONE, float limitTime = -1.0f );
int MessageProcessOk();
int MessageProcessCancel();
void ExitMessage();
void AddSysVAMessage( DWORD color , LPCTSTR lpszFormat, ...);
void AddSysMessage( char* message, DWORD color = GTHCOLOR_SYSMESSAGE );
void AddNoticeMessage( char* message, DWORD color = GTHCOLOR_NOTICEMESSAGE );
void AddChatMessage( char* message, DWORD color, char* nameMsg, int type = IF_CHATMSG_TYPE_SYSTEM );
void LogoProcess();
void LogoRender();
void RenderChar(void);
BOOL RenderChar_SetChrNameColor(Fx_CHARACTER_t* character);
void RenderChar_SetChrName(char* pName,const Fx_CHARACTER_t* character);
void RenderChar_booth(Fx_CHARACTER_t* character,const vec3_t pos);
void RenderChar_Notice(void);
void RenderChar_Guild(Fx_CHARACTER_t *character,int maxsize,const vec3_t pos,const float zPos,const float wPos);
void RenderChar_render_select_sphere(Fx_CHARACTER_t* character,const int x,const int y,const int maxsize,const float zPos,const float wPos);
void RenderChar_Bubble(Fx_CHARACTER_t *character,const vec3_t pos);
BOOL RenderChar_isOutputGuild(Fx_CHARACTER_t* character);
BOOL RenderChar_isCheatEnable(void);
void RenderChar_DanBattleEffect(Fx_CHARACTER_t* character);
};
#endif
| C++ |
#include "../global_def.h"
#include "IFCommon.h"
CIFEventCraftWin::CIFEventCraftWin( CIFControlNode *pParentControl ) : CIFWindow( pParentControl )
{
int i;
for(i = 0; i < NUM_IT_EVENT_CRAFT_WIN; i ++ )
m_textCtl[i] = new CIFText( this );
m_titleBar = new CIFControl( this );
m_titleBarBottom = new CIFControl( this );
for(i=0;i< MAX_EVENT_CRAFT_ITEM;i++)
{
m_ifcItem[i] = new CIFControl( this );
}
m_progressWin = new CIFControl( this );
m_progressBar = new CIFBarCtl( this );
m_progressAni = new CIFControl( this );
m_okBtn = new CIFButtonCtl( this );
m_cancelBtn = new CIFButtonCtl( this );
m_ResultWin = new CIFControl( this );
m_craftingFlag = false;
m_craftCurrentTime = 0.0f;
m_craftMaxTime = 1.0f;
m_nSelectEventCraftIndex=-1;
Enable( false );
g_ifMng->AddFocus( this );
SetWindowType( IF_EVENT_CRAFT_WINDOW_TYPE );
}
CIFEventCraftWin::~CIFEventCraftWin()
{
}
void CIFEventCraftWin::PrepareControl()
{
CIFControl::PrepareControl( IF_EVENT_CRAFT_WIN );
m_textCtl[IT_EVENT_CRAFT_WIN_TITLE]->PrepareControl( IF_EVENT_CRAFT_WIN_TITLE_TEXT );
m_textCtl[IT_EVENT_CRAFT_WIN_INVEN_0_POS]->PrepareControl( IF_EVENT_CRAFT_WIN_INVEN_0 );
m_textCtl[IT_EVENT_CRAFT_WIN_INVEN_1_POS]->PrepareControl( IF_EVENT_CRAFT_WIN_INVEN_1 );
m_textCtl[IT_EVENT_CRAFT_WIN_INVEN_2_POS]->PrepareControl( IF_EVENT_CRAFT_WIN_INVEN_2 );
m_textCtl[IT_EVENT_CRAFT_WIN_INVEN_3_POS]->PrepareControl( IF_EVENT_CRAFT_WIN_INVEN_3 );
m_textCtl[IT_EVENT_CRAFT_WIN_PROGRESS]->PrepareControl( IF_EVENT_CRAFT_WIN_PROGRESS_TEXT );
m_textCtl[IT_EVENT_CRAFT_WIN_OK]->PrepareControl( IF_EVENT_CRAFT_WIN_OK_TEXT );
m_textCtl[IT_EVENT_CRAFT_WIN_CANCEL]->PrepareControl( IF_EVENT_CRAFT_WIN_CANCEL_TEXT );
m_textCtl[IF_EVENT_CRAFT_WIN_RESULT_TEXT_POS]->PrepareControl( IF_EVENT_CRAFT_WIN_RESULT_TEXT );
m_ResultWin->PrepareControl( IF_EVENT_CRAFT_WIN_RESULT_WIN );
m_titleBar->PrepareControl( IF_EVENT_CRAFT_WIN_TITLE_BAR );
m_titleBarBottom->PrepareControl( IF_EVENT_CRAFT_WIN_TITLE_BAR_BOTTOM );
m_ifcItem[0]->PrepareControl( IF_EVENT_CRAFT_WIN_INVEN_0);
m_ifcItem[1]->PrepareControl( IF_EVENT_CRAFT_WIN_INVEN_1);
m_ifcItem[2]->PrepareControl( IF_EVENT_CRAFT_WIN_INVEN_2);
m_ifcItem[3]->PrepareControl( IF_EVENT_CRAFT_WIN_INVEN_3);
m_ifcItem[4]->PrepareControl( IF_EVENT_CRAFT_WIN_INVEN_4);
m_ifcItem[5]->PrepareControl( IF_EVENT_CRAFT_WIN_INVEN_5);
m_ifcItem[6]->PrepareControl( IF_EVENT_CRAFT_WIN_INVEN_6);
m_ifcItem[7]->PrepareControl( IF_EVENT_CRAFT_WIN_INVEN_7);
m_progressWin->PrepareControl( IF_EVENT_CRAFT_WIN_PROGRESS_WIN );
m_progressBar->PrepareControl( IF_EVENT_CRAFT_WIN_PROGRESS_BAR );
m_progressAni->PrepareAnimControl( IF_EVENT_CRAFT_WIN_PROGRESS_ANIM_0, 4, 300.0f );
m_okBtn->PrepareControl( IF_EVENT_CRAFT_WIN_OK_BTN_0 );
m_cancelBtn->PrepareControl( IF_EVENT_CRAFT_WIN_CANCEL_BTN_0 );
}
int CIFEventCraftWin::WindowFrame()
{
m_textCtl[IT_EVENT_CRAFT_WIN_TITLE]->SetText( g_LPACK.GetMassage( 9, 76 ) );
m_textCtl[IT_EVENT_CRAFT_WIN_TITLE]->SetColor( 0xffffffff );
m_textCtl[IT_EVENT_CRAFT_WIN_PROGRESS]->SetText( g_LPACK.GetMassage( 9, 78 ) );
m_textCtl[IT_EVENT_CRAFT_WIN_PROGRESS]->SetColor( 0xffffffff );
m_textCtl[IT_EVENT_CRAFT_WIN_OK]->SetText( g_LPACK.GetMassage( 9, 77 ) );
m_textCtl[IT_EVENT_CRAFT_WIN_OK]->SetColor( 0xffffffff );
m_textCtl[IT_EVENT_CRAFT_WIN_CANCEL]->SetText( g_LPACK.GetMassage( 0, 521 ) );
m_textCtl[IT_EVENT_CRAFT_WIN_CANCEL]->SetColor( 0xffffffff );
m_progressBar->UpdateBarState( (int)( m_craftMaxTime - m_craftCurrentTime ), (int)m_craftMaxTime );
return( IF_CTL_NONE );
}
void CIFEventCraftWin::Render()
{
if( !State() ) return;
g_ifMng->SetRenderState();
if( m_craftingFlag )
{
g_ifMng->SetRenderState();
m_progressWin->Render();
m_progressBar->Render();
m_progressAni->Render();
g_chatManager->SetOutputType( CHAT_OUTPUT_NORMAL );
g_chatManager->BeginFrame();
{
m_textCtl[IT_EVENT_CRAFT_WIN_PROGRESS]->Render( IF_TEXT_OUTPUT_CENTER );
}
g_chatManager->EndFrame();
return;
}
CIFControl::Render();
m_titleBar->Render();
m_titleBarBottom->Render();
m_ResultWin->Render();
m_okBtn->Render();
m_cancelBtn->Render();
g_ifMng->m_iconCtl->BeginFrame();
{
for( int i = 0; i < MAX_EVENT_CRAFT_ITEM; i ++ )
{
m_ifcItem[i]->Render();
int itemIdx, itemTableIdx, cx, cy;
itemIdx = g_cgv.myCharacterInfo->craftSourceInventory[i];
if( itemIdx >= 0 )
{
cx = m_textCtl[IT_EVENT_CRAFT_WIN_INVEN_0_POS]->m_info.clientX + ( i % 4 ) * 40;
cy = m_textCtl[IT_EVENT_CRAFT_WIN_INVEN_0_POS]->m_info.clientY + ( i / 4 ) * 40;
if(i / 4) cy += 2;
itemTableIdx = g_cgv.myCharacterInfo->item[itemIdx].itemTableIdx;
g_ifMng->m_iconCtl->Draw( cx+2, cy+2, IF_ICON_ITEM, g_itemTable[itemTableIdx].iconItemID );
}
}
}
if(m_nSelectEventCraftIndex >= 0)
{
itemCraftTable_t * pData = Get(m_nSelectEventCraftIndex);
if(pData != NULL && pData->m_btEventType == CRAFT_GIVE_ITEM)
{
int itemTableIdx= pData->m_nResultMark;
if(itemTableIdx >= 0)
{
int cx = m_textCtl[IF_EVENT_CRAFT_WIN_RESULT_TEXT_POS]->m_info.clientX;
int cy = m_textCtl[IF_EVENT_CRAFT_WIN_RESULT_TEXT_POS]->m_info.clientY;
g_ifMng->m_iconCtl->Draw( cx+2, cy+2, IF_ICON_ITEM, g_itemTable[itemTableIdx].iconItemID );
}
}
}
g_ifMng->m_iconCtl->EndFrame();
g_chatManager->SetOutputType( CHAT_OUTPUT_NORMAL );
g_chatManager->BeginFrame();
{
m_textCtl[IT_EVENT_CRAFT_WIN_TITLE]->Render();
m_textCtl[IT_EVENT_CRAFT_WIN_OK]->Render();
m_textCtl[IT_EVENT_CRAFT_WIN_CANCEL]->Render();
g_chatManager->SetOutputType( CHAT_OUTPUT_REVERSE );
g_chatManager->SetReverseSize( -1 );
g_chatManager->SetColor( 0xffffffff );
for(int i = 0; i < MAX_EVENT_CRAFT_ITEM; i ++ )
{
int itemIdx, number, cx, cy;
char szTemp[128];
itemIdx = g_cgv.myCharacterInfo->craftSourceInventory[i];
if( itemIdx >= 0 )
{
if( GTH_IsStackItem( &g_cgv.myCharacterInfo->item[itemIdx] ) )
{
cx = m_textCtl[IT_EVENT_CRAFT_WIN_INVEN_0_POS]->m_info.clientX + ( i % 4 ) * 40;
cy = m_textCtl[IT_EVENT_CRAFT_WIN_INVEN_0_POS]->m_info.clientY + ( i / 4 ) * 40;
if(i / 4) cy += 2;
number = g_cgv.myCharacterInfo->item[itemIdx].durability + 1;
strcpy( szTemp, g_ifMng->GetNumberString( number ) );
g_chatManager->TextOut( cx, cy + 19, szTemp );
}
}
}
}
if(m_nSelectEventCraftIndex >= 0)
{
itemCraftTable_t * pData = Get(m_nSelectEventCraftIndex);
if(pData != NULL && pData->m_btEventType == CRAFT_GIVE_ITEM)
{
int itemTableIdx= pData->m_nResultMark;
if(itemTableIdx >= 0)
{
int cx = m_textCtl[IF_EVENT_CRAFT_WIN_RESULT_TEXT_POS]->m_info.clientX;
int cy = m_textCtl[IF_EVENT_CRAFT_WIN_RESULT_TEXT_POS]->m_info.clientY;
char szTemp[128];
sprintf(szTemp,"%d ",pData->m_lResultNak);
g_chatManager->SetOutputType( CHAT_OUTPUT_NORMAL );
g_chatManager->SetReverseSize( -1 );
g_chatManager->SetColor( 0xffffffff );
g_chatManager->TextOut( cx + 40, cy + 15, szTemp );
}
}
}
g_chatManager->EndFrame();
}
int CIFEventCraftWin::WindowSelection()
{
int ret;
ret = m_titleBar->Selection();
if( ret == IF_LBDN ) return( IF_CTL_BEGIN_MOVING );
ret = Selection();
if( ret == IF_LBDN ) return( IF_CTL_SELECT );
return( IF_CTL_NONE );
}
int CIFEventCraftWin::WindowProcess()
{
int itemIdx, mouseItemIdx;
int pos;
int mx, my;
if( m_craftingFlag )
{
m_craftCurrentTime -= g_timer.GetElapsedMilliTime();
if( m_craftCurrentTime < 0.0f )
{
GTH_SendMessage_ItemSystem_EventCraftComplete();
m_craftingFlag = false;
}
}
if( m_cancelBtn->ProcessButton() == IF_CTL_SELECT )
{
if( !m_craftingFlag )
{
GTH_SendMessage_ItemSystem_EventCraftClose();
}
else
{
m_craftingFlag = false;
m_okBtn->SetButtonState( IF_BTN_TYPE_ENABLE );
}
}
if( m_okBtn->ProcessButton() == IF_CTL_SELECT ) GTH_SendMessage_ItemSystem_EventCraftPrepare();
if( m_craftingFlag ) return( IF_CTL_NONE );
pos = -1;
mx = g_input->GetPosX() - m_textCtl[IT_EVENT_CRAFT_WIN_INVEN_0_POS]->GetXPos();
my = g_input->GetPosY() - m_textCtl[IT_EVENT_CRAFT_WIN_INVEN_0_POS]->GetYPos();
if( mx <= 0 || my <= 0 ) return( IF_CTL_NONE );
if( mx >= EVENT_CRAFT_ITEM_SIZE * 4 || my >= EVENT_CRAFT_ITEM_SIZE * 2 ) return( IF_CTL_NONE );
int temp,x,y;
temp = mx / EVENT_CRAFT_ITEM_SIZE;
x = temp % 4;
temp = my / EVENT_CRAFT_ITEM_SIZE;
y = temp % 2;
pos = y * 4 + x;
if( pos < 0 || pos >= MAX_EVENT_CRAFT_ITEM )
{
return( IF_CTL_NONE );
}
itemIdx = g_cgv.myCharacterInfo->craftSourceInventory[pos];
mouseItemIdx = g_cgv.myCharacterInfo->mouseInventory;
if( g_input->GetLBNone() )
{
if( itemIdx < 0 ) return( IF_CTL_NONE );
g_ifMng->InitRolloverText();
g_ifMng->MakeItemRollover( &g_cgv.myCharacterInfo->item[itemIdx] );
g_ifMng->MakeRolloverText( g_input->GetPosX(), g_input->GetPosY(), true, 250 );
}
if( g_input->GetLBUp() )
{
if( g_cgv.myCharacterInfo->curItemWeight > g_cgv.myCharacterInfo->calItemWeight )
{
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage( 0, 589 ) );
return( IF_CTL_NONE );
}
if( mouseItemIdx < 0 && itemIdx < 0 ) return IF_CTL_NONE;
GTH_SendMessage_ItemSystem_EventCraftItem( 0, pos );
}
return IF_CTL_NONE;
}
int CIFEventCraftWin::GetEventCraftFormula()
{
int i, j, k, itemIdx;
int itemTableIdx1, itemTableIdx2, checkedNumber;
int numSourceItem, checkedItem[MAX_EVENT_CRAFT_ITEM], checkedIdx[MAX_EVENT_CRAFT_ITEM];
item_t *sourceItem;
numSourceItem = 0;
for( i = 0; i < MAX_EVENT_CRAFT_ITEM; i ++ )
{
if( g_cgv.myCharacterInfo->craftSourceInventory[i] < 0 ) continue;
sourceItem = &g_cgv.myCharacterInfo->item[g_cgv.myCharacterInfo->craftSourceInventory[i]];
checkedIdx[numSourceItem] = i;
numSourceItem ++;
}
if( numSourceItem == 0 ) return -1;
for( i = 0; i < GetTableSize(); i ++ )
{
itemCraftTable_t *pData = Get(i);
if(pData == NULL) break;
if( numSourceItem != pData->numSourceItem ) continue;
checkedNumber = numSourceItem;
for( j = 0; j < MAX_EVENT_CRAFT_ITEM; j ++ )
{
checkedItem[j] = false;
}
for( j = 0; j < MAX_EVENT_CRAFT_ITEM; j ++ )
{
for( k = 0; k < numSourceItem; k ++ )
{
if( checkedItem[k] ) continue;
itemIdx = g_cgv.myCharacterInfo->craftSourceInventory[checkedIdx[k]];
sourceItem = &g_cgv.myCharacterInfo->item[itemIdx];
itemTableIdx1 = sourceItem->itemTableIdx;
itemTableIdx2 = pData->sourceItem[j].itemIndex;
if( itemTableIdx1 != itemTableIdx2 ) continue;
if( g_itemTable[itemTableIdx1].stackFlag && g_itemTable[itemTableIdx2].stackFlag )
{
if( pData->sourceItem[j].itemCount != sourceItem->durability + 1 ) continue;
}
break;
}
if( k == numSourceItem ) break;
checkedItem[k] = true;
checkedNumber --;
}
if( checkedNumber == 0 )
{
return i;
}
}
return -1;
}
void CIFEventCraftWin::InitCraft()
{
for( int i = 0; i < MAX_CRAFT_SOURCE_ITEM_SIZE; i ++ )
{
g_cgv.myCharacterInfo->craftSourceInventory[i] = -1;
}
m_nSelectEventCraftIndex=-1;
m_okBtn->SetButtonState( IF_BTN_TYPE_ENABLE );
m_craftingFlag = false;
}
void CIFEventCraftWin::UndoCraft()
{
item_t *item;
int itemIdx, inventoryPos;
for( int i = 0; i < MAX_CRAFT_SOURCE_ITEM_SIZE; i ++ )
{
itemIdx = g_cgv.myCharacterInfo->craftSourceInventory[i];
if( itemIdx < 0 ) continue;
item = &g_cgv.myCharacterInfo->item[itemIdx];
int stackItemIdx = GTH_StackMyItem( item );
if( stackItemIdx >= 0 )
{
g_cgv.myCharacterInfo->item[stackItemIdx].durability += item->durability + 1;
if( g_cgv.myCharacterInfo->item[stackItemIdx].durability + 1 >= MAX_COUNT_STACK_ITEM )
g_cgv.myCharacterInfo->item[stackItemIdx].durability = MAX_COUNT_STACK_ITEM - 1;
GTH_DeleteMyItem( item );
}
else
{
inventoryPos = GTH_FindEmptyInventoryPos();
if( inventoryPos >= 0 )
{
g_cgv.myCharacterInfo->inventory[inventoryPos] = itemIdx;
}
}
}
InitCraft();
Enable( false );
}
void CIFEventCraftWin::StartCraft( float craftMaxTime )
{
m_craftMaxTime = craftMaxTime;
m_craftCurrentTime = craftMaxTime;
m_progressBar->UpdateBarState( m_craftMaxTime - m_craftCurrentTime, (int)m_craftMaxTime );
m_craftingFlag = true;
}
| C++ |
#if !defined(AFX_IFBARCTL_H__CF83FBFD_35C1_4108_8E5A_26315B0948AE__INCLUDED_)
#define AFX_IFBARCTL_H__CF83FBFD_35C1_4108_8E5A_26315B0948AE__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CIFBarCtl : public CIFControlNode
{
public:
int m_state;
int m_curPos;
int m_maxPos;
int m_barID;
int m_emptyBarID;
int m_barSize;
int m_barPosX;
CIFControl *m_bar;
CIFControl *m_emptyBar;
CIFBarCtl( CIFControlNode *pParentControl = NULL );
virtual ~CIFBarCtl();
int State() { return( m_state ); }
void Enable( int state = true ) { m_state = state; }
virtual void SetDevice( LPDIRECT3DDEVICE8 pD3DDevice );
virtual void SetTexManager( CD3DTextureMng *texMng );
virtual void PrepareControl( int barID, int emptyBarID = -1 );
virtual void UpdateControl();
virtual void PrepareBuffer();
virtual void UpdateBuffer();
virtual void Release();
virtual void Render();
void UpdateBarState( int curPos, int maxPos );
void UpdateBarState_Inverse( int curPos, int maxPos );
};
#endif
| C++ |
#include "../global_def.h"
#include "IFCommon.h"
CIFScrollBar::CIFScrollBar( CIFControlNode *pParentControl ) : CIFControlNode( pParentControl )
{
m_bgBar = new CIFControl( this );
m_bar = new CIFControl( this );
m_upBtn = new CIFButtonCtl( this );
m_dnBtn = new CIFButtonCtl( this );
m_state = true;
m_max = 5;
m_current = 0;
m_barType = 0;
m_barOriginalPos = 0;
m_barPos = 0;
m_barSize = 0;
}
CIFScrollBar::~CIFScrollBar()
{
}
void CIFScrollBar::SetDevice( LPDIRECT3DDEVICE8 pD3DDevice )
{
m_bgBar->SetDevice( pD3DDevice );
m_bar->SetDevice( pD3DDevice );
m_upBtn->SetDevice( pD3DDevice );
m_dnBtn->SetDevice( pD3DDevice );
CIFControlNode::SetDevice( pD3DDevice );
}
void CIFScrollBar::SetTexManager( CD3DTextureMng *texMng )
{
m_bgBar->SetTexManager( texMng );
m_bar->SetTexManager( texMng );
m_upBtn->SetTexManager( texMng );
m_dnBtn->SetTexManager( texMng );
CIFControlNode::SetTexManager( texMng );
}
void CIFScrollBar::PrepareControl( int id )
{
m_bgBar->PrepareControl( id+1 );
m_upBtn->PrepareControl( id+2 );
m_dnBtn->PrepareControl( id+5 );
m_bar->PrepareControl( id+8 );
if( m_barType == 0 )
{
m_barOriginalPos = g_ifMng->m_iPos[ m_bar->m_info[0].ID ].clientY;
m_barSize = m_bgBar->m_info[0].sizeY - ( m_upBtn->m_info[0].sizeY + m_dnBtn->m_info[0].sizeY + m_bar->m_info[0].sizeY );
}
else
{
m_barOriginalPos = g_ifMng->m_iPos[ m_bar->m_info[0].ID ].clientX;
m_barSize = m_bgBar->m_info[0].sizeX - ( m_upBtn->m_info[0].sizeX + m_dnBtn->m_info[0].sizeX + m_bar->m_info[0].sizeX );
}
SetBarPosition( m_max, m_current );
m_bar->UpdateControl();
}
void CIFScrollBar::UpdateControl()
{
m_bgBar->UpdateControl();
m_bar->UpdateControl();
m_upBtn->UpdateControl();
m_dnBtn->UpdateControl();
CIFControlNode::UpdateControl();
}
void CIFScrollBar::PrepareBuffer()
{
m_bgBar->PrepareBuffer();
m_bar->PrepareBuffer();
m_upBtn->PrepareBuffer();
m_dnBtn->PrepareBuffer();
CIFControlNode::PrepareBuffer();
}
void CIFScrollBar::UpdateBuffer()
{
m_bgBar->UpdateBuffer();
m_bar->UpdateBuffer();
m_upBtn->UpdateBuffer();
m_dnBtn->UpdateBuffer();
CIFControlNode::UpdateBuffer();
}
void CIFScrollBar::Release()
{
m_bgBar->Release();
m_bar->Release();
m_upBtn->Release();
m_dnBtn->Release();
CIFControlNode::Release();
}
void CIFScrollBar::Render()
{
if( !State() ) return;
m_bgBar->Render();
m_bar->Render();
m_upBtn->Render();
m_dnBtn->Render();
}
int CIFScrollBar::ProcessScrollBar()
{
if( m_max > 0 )
{
if( m_upBtn->ProcessButton() == IF_CTL_SELECT )
{
if( m_current > 0 )
{
m_current--;
SetBarPosition( m_max, m_current );
}
return IF_CTL_SELECT;
}
if( m_dnBtn->ProcessButton() == IF_CTL_SELECT )
{
if( m_current < m_max )
{
m_current++;
SetBarPosition( m_max, m_current );
}
return IF_CTL_SELECT;
}
if( m_bar->Selection() == IF_LBDN )
{
m_scrollBarDragFlag = true;
}
if( g_input->GetLBNone() ) m_scrollBarDragFlag = false;
if( m_scrollBarDragFlag )
{
int mousePos, mousePosIdx = -1;
int scrollSize;
float scrollUnitSize;
int numScrollMsg;
if( m_barType == 0 )
scrollSize = m_bgBar->GetYSize() - ( m_upBtn->GetYSize() + m_dnBtn->GetYSize() + m_bar->GetYSize() );
else
scrollSize = m_bgBar->GetXSize() - ( m_upBtn->GetXSize() + m_dnBtn->GetXSize() + m_bar->GetXSize() );
numScrollMsg = m_max;
if( numScrollMsg <= 0 ) return IF_CTL_NONE;
scrollUnitSize = (float)scrollSize / (float)numScrollMsg;
if( m_barType == 0 )
{
mousePos = g_input->GetPosY();
mousePos -= m_bgBar->GetYPos() + m_upBtn->GetYSize() + m_bar->GetYSize() / 2;
for( int i=0; i<=numScrollMsg; i++ )
{
if( mousePos >= ( i * scrollUnitSize - m_bar->GetYSize() / 2 ) && mousePos <= ( i * scrollUnitSize + m_bar->GetYSize() / 2 ) )
mousePosIdx = i;
}
}
else
{
mousePos = g_input->GetPosX();
mousePos -= m_bgBar->GetXPos() + m_upBtn->GetXSize() + m_bar->GetXSize() / 2;
for( int i=0; i<=numScrollMsg; i++ )
{
if( mousePos >= ( i * scrollUnitSize - m_bar->GetXSize() / 2 ) && mousePos <= ( i * scrollUnitSize + m_bar->GetXSize() / 2 ) )
mousePosIdx = i;
}
}
if( mousePosIdx == -1 )
return IF_CTL_NONE;
m_current = mousePosIdx;
if( m_current < 0 )
m_current = 0;
SetBarPosition( m_max, m_current );
return( IF_CTL_SELECT );
}
}
return( IF_CTL_NONE );
}
void CIFScrollBar::SetBarPosition(int max, int cur)
{
if( max != -1 )
m_max = max;
if( cur != -1 )
m_current = cur;
else
m_current = 0;
if( m_max < m_current )
{
m_current = m_max;
}
if( m_max != 0 )
m_barPos = (int)( m_barSize * ( (float)m_current / (float)m_max ) );
else
m_barPos = 0;
if( m_barType == 0 )
g_ifMng->m_iPos[ m_bar->m_info[0].ID ].clientY = m_barOriginalPos + m_barPos;
else
g_ifMng->m_iPos[ m_bar->m_info[0].ID ].clientX = m_barOriginalPos + m_barPos;
if( cur == -1 )
{
if( m_barType == 0 )
g_ifMng->m_iPos[ m_bar->m_info[0].ID ].clientY = m_barOriginalPos + m_barSize;
else
g_ifMng->m_iPos[ m_bar->m_info[0].ID ].clientX = m_barOriginalPos + m_barSize;
}
m_bar->UpdateControl();
}
void CIFScrollBar::SetBarPositionCurrent( int cur )
{
SetBarPosition( m_max, cur );
}
void CIFScrollBar::SetBarPositionMax()
{
SetBarPosition( m_max, m_max );
}
| C++ |
#if !defined(AFX_IFMSGWIN_H__0DC3BC64_6B6C_4FA8_9280_6B6B16D888D0__INCLUDED_)
#define AFX_IFMSGWIN_H__0DC3BC64_6B6C_4FA8_9280_6B6B16D888D0__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
enum
{
IT_MESSAGE_WIN_TITLE = 0,
IT_MESSAGE_WIN_U,
NUM_IT_MESSAGE_WIN
};
class CIFMsgWin : public CIFWindow
{
public:
int m_buttonType;
bool m_bInputMode;
CIFText *m_textCtl[NUM_IT_MESSAGE_WIN];
CIFControl *m_titleBar;
CIFControl *m_titleBottom;
CIFControl *m_line;
CIFButtonCtl *m_okBtn;
CIFButtonCtl *m_cancelBtn;
CIFButtonCtl *m_okCenterBtn;
CIFControl *m_inputBar;
CIFMsgWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFMsgWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
};
enum
{
IT_STACK_WIN_TITLE = 0,
IT_STACK_WIN_INPUT,
IT_STACK_WIN_INPUT_U,
IT_STACK_WIN_INPUT_NUM_U,
IT_STACK_WIN_NUM_POS_0,
IT_STACK_WIN_NUM_POS_1,
IT_STACK_WIN_NUM_POS_2,
IT_STACK_WIN_NUM_POS_3,
IT_STACK_WIN_NUM_POS_4,
IT_STACK_WIN_NUM_POS_5,
IT_STACK_WIN_NUM_POS_6,
IT_STACK_WIN_NUM_POS_7,
IT_STACK_WIN_NUM_POS_8,
IT_STACK_WIN_NUM_POS_9,
NUM_IT_STACK_WIN
};
#define MAX_COUNT_IF_STACK_WIN_NUM 10
enum
{
IF_STACK_TYPE_INVENTORY,
IF_STACK_TYPE_BUY_ITEM,
IF_STACK_TYPE_BUY_SKILL,
IF_STACK_TYPE_EPACK,
IF_STACK_TYPE_TRADE_SE,
IF_STACK_TYPE_DEPOT,
IF_STACK_TYPE_DEPOT_SAVE_SE,
IF_STACK_TYPE_DEPOT_LOAD_SE,
IF_STACK_TYPE_BUY_BOOTH_ITEM,
IF_STACK_TYPE_SELL_BOOTH_PRICE,
IF_STACK_TYPE_BATTING_TRADE,
IF_STACK_TYPE_MAILBOX_SEND,
IF_STACK_TYPE_HELPERSYSTEM_MYPOINT,
};
class CIFStackWin : public CIFWindow
{
public:
CIFText* m_textCtl[NUM_IT_STACK_WIN];
CIFControl* m_titleBar;
CIFControl* m_titleBottom;
CIFControl* m_inputBar;
CIFControl* m_inputNumBar;
CIFControl* m_numBar;
CIFControl* m_line;
CIFButtonCtl* m_numUpBtn[MAX_COUNT_IF_STACK_WIN_NUM];
CIFButtonCtl* m_numDnBtn[MAX_COUNT_IF_STACK_WIN_NUM];
CIFButtonCtl* m_okBtn;
CIFButtonCtl* m_cancelBtn;
CIFButtonCtl* m_closeBtn;
int m_stackType;
int m_count;
int m_maxCount;
int m_saveInvenPos;
int m_saveItemPrice;
int m_chargeType;
float m_chargeCost;
CIFStackWin( CIFControlNode* pParentControl = NULL );
virtual ~CIFStackWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
void InitStack( char* str, item_t* item, int type, int invenPos = 0, float price = 0.0f );
int GetCount() { return( m_count ); }
};
class CIFMenuWin : public CIFWindow
{
public:
CIFMenuWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFMenuWin();
CIFButtonCtl *m_charBtn;
CIFButtonCtl *m_itemBtn;
CIFButtonCtl *m_skillBtn;
CIFButtonCtl *m_questBtn;
CIFButtonCtl *m_communityBtn;
CIFButtonCtl *m_guildBtn;
CIFButtonCtl *m_optionBtn;
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
};
enum
{
IT_MAP_WIN_MINI_TITLE,
IT_MAP_WIN_MINI_MAP_POS,
IT_MAP_WIN_POSITION,
NUM_IT_MINI_MAP_WIN
};
class CIFMiniMapWin : public CIFWindow
{
public:
CIFText *m_textCtl[NUM_IT_MINI_MAP_WIN];
CIFControl *m_titleBar;
CIFButtonCtl *m_closeBtn;
CIFButtonCtl *m_zoomInBtn;
CIFButtonCtl *m_zoomOutBtn;
CIFButtonCtl *m_mapOpenBtn;
CIFControl *m_myImg;
CIFControl *m_entityImg[MAX_CHAR_A_SCENE];
CIFMiniMapWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFMiniMapWin();
CD3DBuffer *m_miniMapVexbuf;
float m_realMapSize;
virtual void PrepareControl();
virtual void PrepareBuffer();
virtual void UpdateBuffer();
virtual void Release();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
int Selection();
};
enum
{
IT_MAP_WIN_TITLE,
NUM_IT_MAP_WIN
};
#define MAX_NUMBER_OF_MAP_NPCICON 100
typedef struct
{
vec3_t position;
int iconType;
int tableIdx;
int linkedWorldIdx;
int size;
} mapNpcIconInfo_t;
class CIFMapWin : public CIFWindow
{
public:
CIFText *m_textCtl[NUM_IT_MAP_WIN];
CIFControl *m_titleBar;
CIFButtonCtl *m_closeBtn;
CIFControl *m_myImg;
CIFControl *m_npcImg[MAX_NUMBER_OF_MAP_NPCICON];
mapNpcIconInfo_t m_npcInfo[MAX_NUMBER_OF_MAP_NPCICON];
int m_numNpcInfo;
int m_npcZoomType;
float m_npcZoomSize;
CIFMapWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFMapWin();
CD3DBuffer *m_mapVexbuf;
int m_mapTextureID;
void AddTextureToManager();
void UpdateTextureID();
virtual void PrepareControl();
virtual void PrepareBuffer();
virtual void UpdateBuffer();
virtual void Release();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
};
enum
{
IT_GM_WIN_TITLE = 0,
IT_GM_WIN_NAME_U,
IT_GM_WIN_U,
IT_GM_WIN_SELECT_U,
IT_GM_WIN_GOLRYUN_U,
NUM_IT_GM_WIN
};
#define MAX_NUMBER_OF_GM_CALLER_NAME 16
class CIFGmWin : public CIFWindow
{
public:
enum GM_GolryunCommand
{
start_battle = 0,
start_join,
start_recall_fighter,
check_join_num,
close_join,
start_betting,
check_betting_nak,
ready_tournament,
start_tournament,
cancel_tournament,
close_battle,
force_join_fighter,
force_eject,
check_status_pvpMode,
};
CIFText *m_textCtl[NUM_IT_GM_WIN];
CIFControl *m_titleBar;
CIFControl *m_titleBarBottom;
CIFControl *m_selectBar;
CIFControl *m_nameSelectBar;
CIFButtonCtl *m_closeBtn;
CIFButtonCtl *m_prevBtn;
CIFButtonCtl *m_nextBtn;
int m_selectedIdx;
int m_nameSelectedIdx;
int m_golryunSelectedIdx;
int m_curPage;
int m_maxPage;
int m_selectBarSavePos;
int m_nameSelectBarSavePos;
int m_numCaller;
CIFGmWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFGmWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
void AddCaller( char* name, char* reason );
void DelCaller( char* name );
void ProcessGM();
void ProcessGMGolryunCommand(void);
};
enum
{
IT_HELP_WIN_TITLE = 0,
IT_HELP_WIN_HOME_BUTTON,
IT_HELP_WIN_PREV_BUTTON,
IT_HELP_WIN_NEXT_BUTTON,
IT_HELP_WIN_HELP,
NUM_IT_HELP_WIN
};
class CIFHelpWin : public CIFWindow
{
public:
CIFText *m_textCtl[NUM_IT_HELP_WIN];
CIFControl *m_titleBar;
CIFControl *m_titleBarBottom;
CIFButtonCtl *m_closeBtn;
CIFButtonCtl *m_homeBtn;
CIFButtonCtl *m_prevBtn;
CIFButtonCtl *m_nextBtn;
CIFScrollBar *m_scrollBar;
CIFHyperLink *m_textHyperLink;
int m_helpIndex;
int m_prevIndex, m_nextIndex;
CIFHelpWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFHelpWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
};
enum
{
IT_TIP_WIN_TITLE,
IT_TIP_WIN_TIP,
NUM_IT_TIP_WIN
};
class CIFTipWin : public CIFWindow
{
public:
CIFText *m_textCtl[NUM_IT_TIP_WIN];
CIFControl *m_titleBar;
CIFButtonCtl *m_closeBtn;
CIFButtonCtl *m_nextBtn;
char m_tipStr[256];
int m_tipIdx;
int m_maxtip;
float m_curTick;
int m_winOriginYPos;
int m_winRelativeYPos;
bool m_bTip;
CIFTipWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFTipWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
int Selection();
void Open();
bool CanOpen();
void SetTipState(bool bTip);
};
enum
{
AUTO_QUEST_SCROLL_TITLE = 0,
AUTO_QUEST_SCROLL_STORY,
AUTO_QUEST_SCROLL_MESSAGE,
NUM_AUTO_QUEST_WIN
};
typedef enum
{
AUTO_WIDE_START,
AUTO_SCROLL_ORDER,
AUTO_SCROLL_START,
AUTO_SCROLL_FAIL,
AUTO_SCROLL_COMPLETE,
AUTO_EFFECT_PROCESS,
AUTO_EFFECT_END,
AUTO_WIDE_END,
AUTO_SCROLL_END,
AUTO_SCROLL_ENDMESSAGE,
NUM_AUTO_SCROLL
}eAutoScrollType;
class CIFAutoQuestWin : public CIFWindow
{
public:
CIFText *m_textCtl[NUM_AUTO_QUEST_WIN];
CIFControl *m_wideUp;
CIFControl *m_wideDown;
CIFButtonCtl *m_startBtn;
CIFButtonCtl *m_closeBtn;
float m_totalTime;
float m_curTick;
int m_arrEffIdx;
int m_questIdx;
float m_fWideUpPosY;
float m_fWideDownPosY;
float m_fAngle;
bool m_wideEnable;
bool m_scrollEnable;
int m_iautoflag;
BOOL m_bComplete;
eAutoScrollType m_eType;
eAutoScrollType m_eMsgtype;
CIFAutoQuestWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFAutoQuestWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
void WideRender();
void ScrollRender();
void MessageRender(void);
void WideEnable( int state = true ) { m_wideEnable = state; }
int WideState() { return( m_wideEnable ); }
void ScrollEnable( int state = true ) { m_scrollEnable = state; }
int ScrollState() { return( m_scrollEnable ); }
};
enum
{
IT_CRAFTHELP_WIN_TITLE = 0,
IT_CRAFTHELP_WIN_RESULT_INVEN_0_POS,
IT_CRAFTHELP_WIN_RESULT_INVEN_1_POS,
IT_CRAFTHELP_WIN_SOURCE_INVEN_POS,
IT_CRAFTHELP_WIN_SEARCH_POS,
IF_CRAFTHELP_WIN_MEMBERSHIP_POS,
NUM_IT_CRAFTHELP_WIN
};
class CIFCraftHelpWin : public CIFWindow
{
public:
CIFText *m_textCtl[NUM_IT_CRAFTHELP_WIN];
CIFControl *m_titleBar;
CIFControl *m_titleBarBottom;
CIFControl *m_searchText;
CIFControl *m_MemberShipBar;
CIFControl *m_searchItemBox[32];
CIFButtonCtl *m_prevBtn;
CIFButtonCtl *m_nextBtn;
CIFButtonCtl *m_closeBtn;
CIFButtonCtl *m_totalViewBtn;
CIFButtonCtl *m_searchViewBtn;
CIFButtonCtl *m_searchBtn;
int m_totalMaxCraftFormula;
int m_totalCurCraftFormula;
int m_searchMaxCraftFormula;
int m_searchCurCraftFormula;
int m_curType;
char m_searchStr[128];
int m_checkInventory[MAX_INVENTORY_SIZE];
vector<itemCraftTable_t *> m_sSearchCraftTable;
CIFCraftHelpWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFCraftHelpWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
void MakeCraftItem( item_t *item, itemCraftTable_t *pCraftTbl, int type, int itemIdx );
void SetCraftHelpWin( char* searchStr );
void SearchCraftFormula();
int CheckMyItem( int itemTableIdx, int count );
};
enum
{
IT_TUTORIAL_WIN_TITLE = 0,
IT_TUTORIAL_WIN_NAME_U,
IT_TUTORIAL_WIN_CHAT_U,
IT_TUTORIAL_WIN_SELECT_U,
NUM_IT_TUTORIAL_WIN
};
#define MAX_COUNT_IF_HELP_SELECT_STRING 10
class CIFTutorialWin : public CIFWindow
{
public:
CIFText *m_textCtl[NUM_IT_TUTORIAL_WIN];
CIFControl *m_titleBar;
CIFControl *m_titleBarBottom;
CIFControl *m_selectBar;
CIFButtonCtl *m_closeBtn;
CIFButtonCtl *m_prevBtn;
CIFButtonCtl *m_nextBtn;
char m_messageStr[4096];
chatMessage m_selectStr[MAX_COUNT_IF_HELP_SELECT_STRING];
int m_numSelectStr;
int m_selectedIdx;
int m_msgIndex;
int m_curPage;
int m_maxPage;
int m_selectBarSavePos;
int m_tutorialFlag;
int m_tipFlag;
CIFTutorialWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFTutorialWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
void InitHelp();
void QuitHelp();
void MakeMessage( int idx );
void MakeSelectMessage( int pos, int idx );
};
enum
{
IT_OPTION_WIN_TITLE = 0,
IT_OPTION_WIN_HELP,
IT_OPTION_WIN_OPTION,
IT_OPTION_WIN_RESTART,
IT_OPTION_WIN_EXIT,
NUM_IT_OPTION_WIN
};
class CIFOptionWin : public CIFWindow
{
public:
CIFText *m_textCtl[NUM_IT_OPTION_WIN];
CIFControl *m_titleBar;
CIFControl *m_titleBottom;
CIFButtonCtl *m_helpBtn;
CIFButtonCtl *m_optionBtn;
CIFButtonCtl *m_restartBtn;
CIFButtonCtl *m_exitBtn;
CIFButtonCtl *m_closeBtn;
CIFOptionWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFOptionWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
};
enum
{
IT_SETTING_WIN_TITLE,
IT_SETTING_WIN_AUTOTIP,
IT_SETTING_WIN_BGMVOLUME,
IT_SETTING_WIN_EFFECTVOLUME,
IT_SETTING_WIN_ON1,
IT_SETTING_WIN_OFF1,
IT_SETTING_WIN_ON2,
IT_SETTING_WIN_OFF2,
IT_SETTING_WIN_ON3,
IT_SETTING_WIN_OFF3,
NUM_IT_SETTING_WIN
};
class CIFSettingWin : public CIFWindow
{
public:
CIFText *m_textCtl[NUM_IT_SETTING_WIN];
CIFControl *m_titleBar;
CIFControl *m_titleBarBottom;
CIFButtonCtl *m_closeBtn;
CIFCheckBox *m_autoTipOnCheckBox;
CIFCheckBox *m_autoTipOffCheckBox;
CIFCheckBox *m_bgmOnCheckBox;
CIFCheckBox *m_bgmOffCheckBox;
CIFCheckBox *m_effectOnCheckBox;
CIFCheckBox *m_effectOffCheckBox;
CIFScrollBar *m_bgmScrollBar;
CIFScrollBar *m_effectScrollBar;
OptionSet_t m_optionSetInfo;
CIFSettingWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFSettingWin();
virtual void PrepareControl();
virtual void Render();
int WindowFrame();
int WindowProcess();
int WindowSelection();
int Selection();
void SetOptionSet();
void GetOptionSet();
};
enum
{
IT_WORLD_CHANGE_WIN_TITLE = 0,
IT_WORLD_CHANGE_WIN_MESSAGE,
IT_WORLD_CHANGE_WIN_SELECT,
IT_WORLD_CHANGE_WIN_CANCEL,
IT_WORLD_CHANG_WIN_LIST_POS,
NUM_IT_WORLD_CHANGE_WIN,
WORLD_LIST_WIN_MAX_NUM = 13,
WORLD_LIST_WIN_HEIGHT = 17,
WORLD_LIST_SKIP_NUM = 2,
};
class CIFWorld_ChangeWin : public CIFWindow
{
public:
int m_SelectWorldIdx;
int m_WorldCount;
int m_selectBarSavePos;
int m_selectedIdx;
int m_WorldItemIdx;
public:
CIFText *m_textCtl[NUM_IT_WORLD_CHANGE_WIN];
CIFControl *m_titleBar;
CIFControl *m_titleBarBottom;
CIFControl *m_ButtonBgBar;
CIFControl *m_MessageBgBar;
CIFButtonCtl *m_closeBtn;
CIFButtonCtl *m_selectBtn;
CIFButtonCtl *m_cancelBtn;
CIFScrollBar *m_scrollBar;
CIFControl *m_selectBar;
public:
int m_MaxDrawWorldListNum;
void WorldListRender();
void SetSelectBar( int idx );
CIFWorld_ChangeWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFWorld_ChangeWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
};
enum
{
IT_SERVER_LIST_WIN_TITLE = 0,
IT_SERVER_LIST_TEXT_MESSAGE,
IT_SERVER_LIST_WIN_SELECT,
IT_SERVER_LIST_WIN_CANCEL,
IT_SERVER_LIST_WIN_LIST_POS,
IT_SERVER_LIST_TEXT,
NUM_IT_SERVERLIST_WIN
};
#define MAX_COUNT_IF_LOGIN_WIN_SERVER_BTN 20
#define SERVER_LIST_SELECTBAR_HEIGHT 15
#define SERVER_LIST_WIN_TOP 70
#define SERVER_LIST_WIN_WIDTH 304
#define SERVER_LIST_WIN_SELECT_LIST 210
class CIFServer_ListWin : public CIFWindow
{
enum
{
SERVERNAME_LEN = 256,
MAX_RENDER_SERVER_LIST_COUNT = 8
};
enum
{
SERVER_ASCENDINGFLAG = 0,
SERVER_DESCENDINGFLAG = 1,
STATE_ASCENDINGFLAG = 2,
STATE_DESCENDINGFLAG = 3
};
public:
std::vector<serverGroup_t> m_vpServerList;
int m_selectBarSavePos;
int m_selectedIdx;
int m_ActiveServerCount;
int m_Server_Sort;
bool m_ServerSort_Flag;
bool m_Server_State_Sort_Flag;
public:
CIFControl *m_login;
CIFText *m_ServerText[MAX_COUNT_IF_LOGIN_WIN_SERVER_BTN];
CIFText *m_ServerClientState[MAX_COUNT_IF_LOGIN_WIN_SERVER_BTN];
CIFText *m_textCtl[NUM_IT_SERVERLIST_WIN];
CIFControl *m_ServerList;
CIFButtonCtl *m_selectBtn;
CIFButtonCtl *m_cancelBtn;
CIFButtonCtl *m_ServerButton;
CIFButtonCtl *m_ServerState;
CIFScrollBar *m_scrollBar;
CIFControl *m_selectBar;
RECT m_ServerListCheckRect;
public:
void ServerListRender();
void SetSelectBar( int idx );
CIFServer_ListWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFServer_ListWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
BOOL CheckSelectServer();
};
#include "NewDanBattleSystem.h"
class CIFDanWarRequestWin : public CIFWindow
{
public:
enum DanWarRequestWinType
{
REQUEST,
EXAMINATION,
RESULT,
} m_DanWarWinType;
public:
CIFText *m_textCtlBoxDoc;
CIFText *m_textCtlDanNameTitle;
CIFText *m_textCtlDanName;
CIFText *m_textCtlWorldTitle;
CIFText *m_textCtlWorldName;
CIFText *m_textCtlDanMemberNumTitle;
CIFText *m_textCtlDanMemberNum;
CIFText *m_textCtlDanWarTypeTitle;
CIFComboBox *m_ComboCtlDanWarType;
CIFText *m_textCtlDanWarTime;
CIFComboBox *m_ComboCtlDanWarTime;
CIFText *m_textCtlWinDanPointTitle;
CIFText *m_textCtlWinDanPoint;
CIFText *m_textCtlLoseDanPointTitle;
CIFText *m_textCtlLoseDanPoint;
CIFText *m_textCtlMyPointTitle;
CIFText *m_textCtlMyPoint;
CIFText *m_textCtlBestIDTitle;
CIFText *m_textCtlBestID;
CIFCheckBox *m_PrimiumItemCheckBox;
CIFText *m_textPrimiumItem;
int m_SaveOkBtnXPos;
CIFButtonCtl *m_OkBtn;
CIFButtonCtl *m_cancelBtn;
public:
void InitDanWarWin(enum DanWarRequestWinType type, class NewDanBattleSystem* pNewDanBattleSystem);
void InitDanWarRequestWin(enum DanWarRequestWinType type, class NewDanBattleSystem* pNewDanBattleSystem);
void InitDanWarExaminationWin(enum DanWarRequestWinType type, class NewDanBattleSystem* pNewDanBattleSystem);
void InitDanWarResultWin(enum DanWarRequestWinType type, class NewDanBattleSystem* pNewDanBattleSystem);
public:
CIFDanWarRequestWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFDanWarRequestWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
};
class CIFDanWarBattleWin : public CIFWindow
{
public:
CIFText *m_textCtlREMAINTIME_TITLE;
CIFText *m_textCtlREMAINTIME_TEXT;
CIFText *m_textCtlREMAINPC_TITLE;
CIFText *m_textCtlREMAINPC_TEXT;
CIFText *m_textCtlMY_GUILD_KILLPOINT_TITLE;
CIFText *m_textCtlMY_GUILD_KILLPOINT_TEXT;
CIFText *m_textCtlPC_KILLPOINT_TITLE;
CIFText *m_textCtlPC_KILLPOINT_TEXT;
CIFText *m_textCtlENEMY_GUILD_KILLPOINT_TITLE;
CIFText *m_textCtlENEMY_GUILD_KILLPOINT_TEXT;
public:
public:
CIFDanWarBattleWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFDanWarBattleWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
};
#endif
| C++ |
#if !defined(AFX_IFROLLOVERWIN_H__86C7061C_25C5_4986_93EA_9A7BCAB84897__INCLUDED_)
#define AFX_IFROLLOVERWIN_H__86C7061C_25C5_4986_93EA_9A7BCAB84897__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CIFRolloverWin : public CIFWindow
{
public:
CIFControl *m_win;
CIFControl *m_titleLeft;
CIFControl *m_titleRight;
CIFControl *m_titleCenter;
CIFControl *m_titleLeftSide;
CIFControl *m_titleRightSide;
CIFControl *m_titleBottom;
char m_str[2048];
int m_outputTextX;
int m_outputTextY;
int m_outputTextXSize;
int m_outputTextYSize;
int m_saveArragneType;
CIFRolloverWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFRolloverWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
void MakeRolloverWindow( int x, int y, char *str, int forcedWinFlag, int xsize, int ysize, int arrangeType );
};
class CIFGuildAuthoritySettingWin : public CIFWindow
{
public:
CIFControl *m_win;
CIFControl *m_titleLeft;
CIFControl *m_titleRight;
CIFControl *m_titleCenter;
CIFControl *m_titleLeftSide;
CIFControl *m_titleRightSide;
CIFControl *m_titleBottom;
CIFButtonCtl *m_joinBtn;
CIFButtonCtl *m_disorganizeBtn;
CIFButtonCtl *m_banishBtn;
CIFButtonCtl *m_setMasterBtn;
CIFButtonCtl *m_applyBloodPledgeBtn;
CIFButtonCtl *m_breakBloodPledgeBtn;
CIFButtonCtl *m_applyBloodPledgeBattleBtn;
CIFButtonCtl *m_requestPvPBtn;
CIFButtonCtl *m_modeSettingBtn;
CIFButtonCtl *m_resetPositionBtn;
char m_str[2048];
int m_outputTextX;
int m_outputTextY;
int m_outputTextXSize;
int m_outputTextYSize;
int m_saveArragneType;
CIFGuildAuthoritySettingWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFGuildAuthoritySettingWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
void MakeRolloverWindow( int x, int y, char *str, int forcedWinFlag, int xsize, int ysize, int arrangeType );
};
#endif
| C++ |
#include "../global_def.h"
#include "IFCommon.h"
#include "../CTools.h"
extern CTools gcTools;
CItem_ScrollWin::CItem_ScrollWin( CIFControlNode *pParentControl ) : CIFWindow( pParentControl )
{
for( int i = 0; i < NUM_IT_ITEM_SCROLLWIN; i ++ )
m_textCtl[i] = new CIFText( this );
m_bgMessage = new CIFControl( this );
m_OkBtn = new CIFButtonCtl( this );
m_cancelBtn = new CIFButtonCtl( this );
Enable( false ,NULL,-1,0);
g_ifMng->AddFocus( this );
SetWindowType( IF_ITEM_SCROLL_WINDOW_TYPE );
Init();
}
CItem_ScrollWin::~CItem_ScrollWin()
{
}
void CItem_ScrollWin::Init()
{
m_InventoryItemPos=-1;
m_RequestPlayerName[0]=NULL;
m_Title[0]=NULL;
m_ItemName[0]=NULL;
m_nWindowType = enumWINDOW_TYPE_ENUM::WT_NORMAL;
m_SendTime=0;
m_bSending=false;
}
void CItem_ScrollWin::Decoder()
{
short PacketID =MSG_ReadShort();
switch(PacketID){
case enumPacketID::GSC_ERROR_MES:
GSC_Error_Mes();
break;
case enumPacketID::GSC_STATE_MES:
GSC_State_Mes();
break;
case enumPacketID::GSC_REQUEST_PC_SUMMON:
GSC_PC_Summon_Mes();
break;
case enumPacketID::GSC_REQUEST_PC_MOVE_SUMMON:
GSC_PC_Move_Summon_Mes();
break;
case enumPacketID::GSC_REPLY_REDAY_PC_MOVE_SUMMON:
Gsc_Reply_Ready_Pc_Move_Summon();
break;
}
return;
}
void CItem_ScrollWin::GSC_Error_Mes()
{
short ErrorCode =MSG_ReadShort();
char RequesterName[NAMESTRING+1];
char TargetterName[NAMESTRING+1];
sstrncpy( RequesterName, MSG_ReadString(), NAMESTRING);
RequesterName[NAMESTRING]=NULL;
sstrncpy( TargetterName, MSG_ReadString(), NAMESTRING);
TargetterName[NAMESTRING]=NULL;
SetWorldChangeMode(WorldChangeSystem::enumWorldChangeSystemMode::WORLD_CHANGESYSTEM_NONE);
Enable( false ,NULL,-1,0);
Init();
switch(ErrorCode)
{
case ERROR_NULL_TARGET_PLAYER:
g_ifMng->SetVAMessage( g_LPACK.GetMessage(0, 322), g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 559),RequesterName,TargetterName);
break;
case ERROR_ITEM_NOT_HAVE:
g_ifMng->SetMessage( g_LPACK.GetMessage(0, 322),g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 560));
break;
case ERROR_INVALID_ITEM:
g_ifMng->SetMessage( g_LPACK.GetMessage(0, 322),g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 561));
break;
case ERROR_NOT_MOVE_SUMMON_ITEM:
g_ifMng->SetMessage( g_LPACK.GetMessage(0, 322),g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 562));
break;
case ERROR_NOT_SUMMON_ITEM:
g_ifMng->SetMessage( g_LPACK.GetMessage(0, 322), g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 563));
break;
case ERROR_NULL_REQUEST_PLAYER:
g_ifMng->SetVAMessage( g_LPACK.GetMessage(0, 322),g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 564),TargetterName,RequesterName);
break;
case ERROR_TARGET_PLAYER_NOT_USE_AREA:
g_ifMng->SetVAMessage( g_LPACK.GetMessage(0, 322), g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 565), TargetterName);
break;
case ERROR_REQUEST_PLAYER_NOT_USE_AREA:
g_ifMng->SetVAMessage( g_LPACK.GetMessage(0, 322),g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 565),RequesterName );
break;
case ERROR_NOT_USE_ME_TO_ME:
g_ifMng->SetMessage( g_LPACK.GetMessage(0, 322),g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 566) );
break;
}
return;
}
void CItem_ScrollWin::GSC_State_Mes()
{
short StateCode =MSG_ReadShort();
char RequesterName[NAMESTRING+1];
char TargetterName[NAMESTRING+1];
SetWorldChangeMode(WorldChangeSystem::enumWorldChangeSystemMode::WORLD_CHANGESYSTEM_NONE);
Enable( false ,NULL,-1,0);
Init();
switch(StateCode)
{
case STATE_MSGBOX_POPUP_SUCC:
case STATE_MSGBOX_POPUP_FAIL:
{
int invenPos =MSG_ReadLong();
sstrncpy( RequesterName, MSG_ReadString(), NAMESTRING);
RequesterName[NAMESTRING]=NULL;
sstrncpy( TargetterName, MSG_ReadString(), NAMESTRING);
TargetterName[NAMESTRING]=NULL;
if(STATE_MSGBOX_POPUP_SUCC == StateCode)
{
if(true == IfWorldChangEffecting())
{
g_ifMng->AddSysMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 586) );
return;
}
g_ifMng->AddSysVAMessage( D3DCOLOR_ARGB(255, 255, 125, 100),g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 567),TargetterName);
gcTools.DeleteInventoryItem(invenPos);
}
else
{
g_ifMng->SetVAMessage(g_LPACK.GetMessage(0, 322),g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 568),TargetterName);
}
}
break;
case STATE_TARGET_PLAYER_REFUSE:
case STATE_TARGET_PLAYER_OK:
{
sstrncpy( RequesterName, MSG_ReadString(), NAMESTRING);
RequesterName[NAMESTRING]=NULL;
sstrncpy( TargetterName, MSG_ReadString(), NAMESTRING );
TargetterName[NAMESTRING]=NULL;
if(STATE_TARGET_PLAYER_OK == StateCode)
{
g_ifMng->AddSysVAMessage( D3DCOLOR_ARGB(255, 255, 125, 100),g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 569), TargetterName);
}
else
{
g_ifMng->SetVAMessage( g_LPACK.GetMessage(0, 322),g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 570) , TargetterName);
}
}
break;
case STATE_TARGET_PLAYER_MOVE_REFUSE:
case STATE_TARGET_PLAYER_MOVE_OK:
{
m_TargetPlayerWorldIdx = MSG_ReadByte();
MSG_ReadPosition(m_TargetPlayerPosition);
sstrncpy( RequesterName, MSG_ReadString(), NAMESTRING);
RequesterName[NAMESTRING]=NULL;
sstrncpy( m_TargetPlayerName, MSG_ReadString(), NAMESTRING );
m_TargetPlayerName[NAMESTRING]=NULL;
bool ResultAllow = IsAllowWorldChange();
if(false == ResultAllow)
{
g_ifMng->SetVAMessage( g_LPACK.GetMessage(0, 322),g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 571) ,RequesterName);
gcTools.CcToGs(ITEM_SUMMON_SYSTEM,CC_ERROR_MES,ERROR_REQUEST_PLAYER_NOT_USE_AREA,RequesterName,m_TargetPlayerName);
return;
}
if(STATE_TARGET_PLAYER_MOVE_OK == StateCode)
{
if(true == IfWorldChangEffecting())
{
g_ifMng->AddSysMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 586) );
return;
}
g_ifMng->AddSysVAMessage( D3DCOLOR_ARGB(255, 255, 125, 100),g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 572), m_TargetPlayerName);
PC_Move_Summon_Proc();
}
else
{
g_ifMng->SetVAMessage( g_LPACK.GetMessage(0, 322), g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 573), m_TargetPlayerName);
}
}
break;
}
return;
}
void CItem_ScrollWin::GSC_PC_Summon_Mes()
{
short subType = MSG_ReadShort();
int InventoryItemPos = MSG_ReadLong();
m_TargetPlayerWorldIdx = MSG_ReadByte();
MSG_ReadPosition(m_TargetPlayerPosition);
sstrncpy( m_RequestPlayerName, MSG_ReadString(), NAMESTRING );
m_RequestPlayerName[NAMESTRING]=NULL;
int resultAllow = IsAllowWorldChange();
if(false == resultAllow )
{
gcTools.CcToGs(ITEM_SUMMON_SYSTEM,CC_STATE_MES,STATE_MSGBOX_POPUP_FAIL,InventoryItemPos,m_RequestPlayerName);
return;
}
if(WorldChangeSystem::enumWorldChangeSystemMode::WORLD_CHANGESYSTEM_NONE != g_cgv.myCharacterInfo->m_WorldChageSystem.m_SystemMode)
{
gcTools.CcToGs(ITEM_SUMMON_SYSTEM,CC_STATE_MES,STATE_MSGBOX_POPUP_FAIL,InventoryItemPos,m_RequestPlayerName);
return;
}
char szTemp[256];
wsprintf(szTemp, g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 574),m_RequestPlayerName);
bool result = g_ifMng->SetMessage( g_LPACK.GetMessage(0,322), szTemp,
MSG_BUTTONTYPE_OKCANCEL, IF_MESSAGE_REQUEST_PC_SUMMON, 10000.0f );
if(false == result)
{
gcTools.CcToGs(ITEM_SUMMON_SYSTEM,CC_STATE_MES,STATE_MSGBOX_POPUP_FAIL,InventoryItemPos,m_RequestPlayerName);
}
else
{
gcTools.CcToGs(ITEM_SUMMON_SYSTEM,CC_STATE_MES,STATE_MSGBOX_POPUP_SUCC,InventoryItemPos,m_RequestPlayerName);
}
return;
}
void CItem_ScrollWin::Select_PC_Summon(int _flag)
{
if(enumTargetPlayerReply::REPLY_OK == _flag)
{
if(true == IfWorldChangEffecting())
{
g_ifMng->AddSysMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 586) );
return;
}
g_effectMng->AddSelfEffect( GTH_EFFECT_CLASS_MODEL,
WorldChangeSystem::WORLD_CHANGE_EFFECT_IDX,
g_pApp->m_myCharacter->position,
NULL,
true,
g_pApp->m_myCharacter->entityType,
g_pApp->m_myCharacter->idxOnServer,
0.0f,
0.0f,
0.0f,
-1.0f,
false,
effectentity_t::enumEffectType::EFFECT_TYPE_PC_SUMMON);
SetWorldChangeMode(WorldChangeSystem::enumWorldChangeSystemMode::WORLD_CHANGESYSTEM_ITEM_MODE);
}
else
{
gcTools.CcToGs(ITEM_SUMMON_SYSTEM,CC_REPLY_PC_SUMMON,enumTargetPlayerReply::REPLY_REFUSE,m_RequestPlayerName);
}
return;
}
void CItem_ScrollWin::Send_Reply_PC_Summon(int _flag)
{
g_ifMng->RestartInterface( 1 );
gcTools.CcToGs(ITEM_SUMMON_SYSTEM,CC_REPLY_PC_SUMMON,enumTargetPlayerReply::REPLY_OK,m_TargetPlayerWorldIdx,m_TargetPlayerPosition,m_RequestPlayerName);
return;
}
void CItem_ScrollWin::PrepareControl()
{
CIFControl::PrepareControl( IF_SCROLL_WIN );
m_textCtl[IT_ITEM_SCROLLWIN_TITLE]->PrepareControl( IF_SCROLL_WIN_TITLE );
m_textCtl[IT_ITEM_SCROLLWIN_ITEM_NAME]->PrepareControl( IF_SCROLL_WIN_ITEM_NAME );
m_OkBtn->PrepareControl( IF_SCROLL_WIN_OK_BTN_0 );
m_cancelBtn->PrepareControl( IF_SCROLL_WIN_CANCEL_BTN_0 );
m_bgMessage->PrepareControl( IF_SCROLL_WIN_MESSAGE );
int cx, cy;
cx = m_bgMessage->GetXPos();
cy = m_bgMessage->GetYPos();
g_chatManager->SetInput( cx, cy, NAMESTRING , NAMESTRING, INPUT_INDEX_ITEM_SCROLL_WINDOW_ID, 1, 130, true );
}
void CItem_ScrollWin::Enable(int state,const item_t *_item,int _InventoryItemPos,int _type)
{
if(1 == state)
{
if(true == IfWorldChangEffecting())
{
g_ifMng->AddSysMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 586) );
return;
}
}
CIFWindow::Enable(state);
m_InventoryItemPos = _InventoryItemPos;
m_nWindowType = _type;
m_bSending = false;
m_SendTime = 0;
if(NULL != _item )
{
strncpy(m_ItemName,_item->name,MAXBYTES_ITEM_NAME);
m_Title[MAXBYTES_ITEM_NAME]=NULL;
}
if(m_nWindowType == WT_PC_SUMMON)
{
strncpy(m_Title,g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 575),MAXBYTES_TITLE);
m_Title[MAXBYTES_TITLE]=NULL;
}
else if(m_nWindowType == WT_PC_MOVE_SUMMON)
{
strncpy(m_Title,g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 576),MAXBYTES_TITLE);
m_Title[MAXBYTES_TITLE]=NULL;
}
if(1 == state)
{
g_chatManager->SetInputState( INPUT_INDEX_ITEM_SCROLL_WINDOW_ID, 1 );
g_chatManager->ChangeInputMessage( INPUT_INDEX_ITEM_SCROLL_WINDOW_ID );
}
return;
}
int CItem_ScrollWin::WindowFrame()
{
m_textCtl[IT_ITEM_SCROLLWIN_TITLE]->SetText(m_Title);
m_textCtl[IT_ITEM_SCROLLWIN_ITEM_NAME]->SetText(m_ItemName);
if(m_nWindowType == WT_PC_SUMMON)
{
m_OkBtn->SetButtonText( g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 577),D3DCOLOR_ARGB(155,253, 237, 193));
m_cancelBtn->SetButtonText(g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 578) ,D3DCOLOR_ARGB(155,253, 237, 193) );
}
else if(m_nWindowType == WT_PC_MOVE_SUMMON)
{
m_OkBtn->SetButtonText( g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 579),D3DCOLOR_ARGB(155,253, 237, 193));
m_cancelBtn->SetButtonText( g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 580),D3DCOLOR_ARGB(155,253, 237, 193) );
}
g_chatManager->m_ix[INPUT_INDEX_ITEM_SCROLL_WINDOW_ID] = m_bgMessage->GetXPos();
g_chatManager->m_iy[INPUT_INDEX_ITEM_SCROLL_WINDOW_ID] = m_bgMessage->GetYPos();
SetWorldChangeMode(WorldChangeSystem::enumWorldChangeSystemMode::WORLD_CHANGESYSTEM_CHECK);
return( IF_CTL_NONE );
}
void CItem_ScrollWin::Render()
{
if( !State() ) return;
g_ifMng->SetRenderState();
CIFControl::Render();
m_OkBtn->RenderTextBtn();
m_cancelBtn->RenderTextBtn();
m_bgMessage->Render();
g_chatManager->SetOutputType( CHAT_OUTPUT_SHADOW );
g_chatManager->BeginFrame();
{
m_textCtl[IT_ITEM_SCROLLWIN_TITLE]->SetColor(D3DCOLOR_ARGB(155,253, 237, 193));
m_textCtl[IT_ITEM_SCROLLWIN_TITLE]->Render(IF_TEXT_OUTPUT_CENTER);
m_textCtl[IT_ITEM_SCROLLWIN_ITEM_NAME]->SetColor(D3DCOLOR_ARGB(155,253, 237, 193));
m_textCtl[IT_ITEM_SCROLLWIN_ITEM_NAME]->Render(IF_TEXT_OUTPUT_CENTER);
g_chatManager->RenderInputFrame( INPUT_INDEX_ITEM_SCROLL_WINDOW_ID );
}
g_chatManager->EndFrame();
if(true == IfWorldChangEffecting())
{
g_ifMng->m_Item_ScrollWin->Select_PC_Summon(CItem_ScrollWin::enumTargetPlayerReply::REPLY_REFUSE);
Enable( false ,NULL,-1,0);
Init();
return;
}
if(true == m_bSending)
{
if(timeGetTime() - m_SendTime > 20000)
{
g_ifMng->AddSysMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 587) );
Enable( false ,NULL,-1,0);
Init();
if(true == IfWorldChangEffecting())
{
return;
}
SetWorldChangeMode(WorldChangeSystem::enumWorldChangeSystemMode::WORLD_CHANGESYSTEM_NONE);
}
}
}
int CItem_ScrollWin::WindowSelection()
{
int ret;
ret = Selection();
if( ret == IF_LBDN )
{
g_chatManager->SetInputState( INPUT_INDEX_ITEM_SCROLL_WINDOW_ID, 1 );
g_chatManager->ChangeInputMessage( INPUT_INDEX_ITEM_SCROLL_WINDOW_ID );
return( IF_CTL_SELECT );
}
return IF_CTL_NONE;
}
int CItem_ScrollWin::WindowProcess()
{
if( m_cancelBtn->ProcessButton() == IF_CTL_SELECT )
{
g_chatManager->InitInputStr( INPUT_INDEX_ITEM_SCROLL_WINDOW_ID );
g_chatManager->SetInputState( INPUT_INDEX_ITEM_SCROLL_WINDOW_ID, -1 );
g_chatManager->ChangeInputMessage( INPUT_INDEX_DIALOGBOX );
Enable( false ,NULL,-1,0);
Init();
return IF_CTL_NONE;
}
if( m_OkBtn->ProcessButton() == IF_CTL_SELECT )
{
char msg[CHATSTRING];
strcpy( msg, g_chatManager->GetInputStr( INPUT_INDEX_ITEM_SCROLL_WINDOW_ID ) );
g_chatManager->InitInputStr( INPUT_INDEX_ITEM_SCROLL_WINDOW_ID );
g_chatManager->SetInputState( INPUT_INDEX_ITEM_SCROLL_WINDOW_ID, -1 );
g_chatManager->ChangeInputMessage( INPUT_INDEX_DIALOGBOX );
if(true == IfWorldChangEffecting())
{
g_ifMng->AddSysMessage(g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 587));
return IF_CTL_SELECT;
}
if(m_nWindowType == WT_PC_SUMMON)
{
gcTools.CcToGs(ITEM_SUMMON_SYSTEM,CC_REQUEST_PC_SUMMON,m_InventoryItemPos,msg);
SetWorldChangeMode(WorldChangeSystem::enumWorldChangeSystemMode::WORLD_CHANGESYSTEM_ITEM_MODE);
m_SendTime= timeGetTime();
m_bSending=true;
}
else if(m_nWindowType == WT_PC_MOVE_SUMMON)
{
int resultAllow = IsAllowWorldChange();
if(false == resultAllow)
{
g_ifMng->SetMessage( g_LPACK.GetMessage(0, 322),g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 581) );
return IF_CTL_NONE;
}
gcTools.CcToGs(ITEM_SUMMON_SYSTEM,CC_REQUEST_PC_MOVE_SUMMON,m_InventoryItemPos,msg);
SetWorldChangeMode(WorldChangeSystem::enumWorldChangeSystemMode::WORLD_CHANGESYSTEM_ITEM_MODE);
m_SendTime= timeGetTime();
m_bSending=true;
}
return IF_CTL_NONE;
}
return IF_CTL_NONE;
}
void CItem_ScrollWin::GSC_PC_Move_Summon_Mes()
{
if(true == IfWorldChangEffecting())
{
g_ifMng->AddSysMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 586) );
return;
}
short subType = MSG_ReadShort();
int InventoryItemPos = MSG_ReadLong();
sstrncpy( m_RequestPlayerName, MSG_ReadString(), NAMESTRING );
m_RequestPlayerName[NAMESTRING]=NULL;
char szTemp[256];
wsprintf(szTemp, g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 582),m_RequestPlayerName);
if(WorldChangeSystem::enumWorldChangeSystemMode::WORLD_CHANGESYSTEM_NONE != g_cgv.myCharacterInfo->m_WorldChageSystem.m_SystemMode)
{
gcTools.CcToGs(ITEM_SUMMON_SYSTEM,CC_STATE_MES,STATE_MSGBOX_POPUP_FAIL,InventoryItemPos,m_RequestPlayerName);
return;
}
bool result = g_ifMng->SetMessage( g_LPACK.GetMessage(0,322), szTemp,
MSG_BUTTONTYPE_OKCANCEL, IF_MESSAGE_REQUEST_PC_MOVE_SUMMON, 10000.0f );
if(false == result)
{
gcTools.CcToGs(ITEM_SUMMON_SYSTEM,CC_STATE_MES,STATE_MSGBOX_POPUP_FAIL,InventoryItemPos,m_RequestPlayerName);
}
else
{
gcTools.CcToGs(ITEM_SUMMON_SYSTEM,CC_STATE_MES,STATE_MSGBOX_POPUP_SUCC,InventoryItemPos,m_RequestPlayerName);
}
return;
}
void CItem_ScrollWin::Select_PC_Move_Summon(int _flag)
{
if(true == IfWorldChangEffecting())
{
gcTools.CcToGs(ITEM_SUMMON_SYSTEM,CC_REPLY_PC_MOVE_SUMMON,CItem_ScrollWin::enumTargetPlayerReply::REPLY_REFUSE,m_RequestPlayerName);
return ;
}
gcTools.CcToGs(ITEM_SUMMON_SYSTEM,CC_REPLY_PC_MOVE_SUMMON,_flag,m_RequestPlayerName);
return;
}
void CItem_ScrollWin::Send_Reday_PC_Move_Summon(int _flag)
{
gcTools.CcToGs(ITEM_SUMMON_SYSTEM,CC_REDAY_PC_MOVE_SUMMON,_flag,m_TargetPlayerWorldIdx,m_TargetPlayerPosition,m_TargetPlayerName);
}
void CItem_ScrollWin::Gsc_Reply_Ready_Pc_Move_Summon()
{
g_ifMng->RestartInterface( 1 );
GTH_SendMessage_ReplySummons(1);
return;
}
void CItem_ScrollWin::PC_Move_Summon_Proc()
{
g_effectMng->AddSelfEffect( GTH_EFFECT_CLASS_MODEL,
WorldChangeSystem::WORLD_CHANGE_EFFECT_IDX,
g_pApp->m_myCharacter->position,
NULL,
true,
g_pApp->m_myCharacter->entityType,
g_pApp->m_myCharacter->idxOnServer,
0.0f,
0.0f,
0.0f,
-1.0f,
false,
effectentity_t::enumEffectType::EFFECT_TYPE_PC_MOVE_SUMMON);
SetWorldChangeMode(WorldChangeSystem::enumWorldChangeSystemMode::WORLD_CHANGESYSTEM_ITEM_MODE);
return;
}
bool CItem_ScrollWin::IsAllowWorldChange()
{
int resultAllow = IsAllowWorldChange_ForPcEvent();
if(1 != resultAllow )
{
return false;
}
if( g_ifMng->m_boothWin->State() )
{
return false;
}
return true;
}
bool CItem_ScrollWin::IfWorldChangEffecting()
{
if(WorldChangeSystem::enumWorldChangeSystemMode::WORLD_CHANGESYSTEM_EFFECT_MODE == g_cgv.myCharacterInfo->m_WorldChageSystem.m_SystemMode)
{
return true;
}
if(1 == g_ifMng->m_changeStateFlag)
{
return true;
}
if( g_cgv.state != CLIENT_GAME_PROCESS)
{
return true;
}
return false;
}
bool CItem_ScrollWin::IfWorldChangeing()
{
if(true == IfWorldChangEffecting())
{
return true;
}
if(1 == CIFWindow::State())
{
return true;
}
return false;
} | C++ |
#include "../global_def.h"
#include "IFCommon.h"
CIFNumCtl::CIFNumCtl()
{
for( int i = 0; i < MAX_COUNT_IF_DAMAGE_NUMBER; i ++ )
{
memset( &m_dmgMsg[i], 0, sizeof( IFDmgNumber_t ) );
m_dmgMsg[i].idx = -1;
}
m_nDmgMsg = 0;
m_nDamageVex = 0;
m_nNumDamage = 0;
m_vexCount = 0;
m_damageVexbuf = NULL;
}
CIFNumCtl::~CIFNumCtl()
{
}
void CIFNumCtl::PrepareBuffer()
{
m_damageVexbuf = new CD3DBuffer();
m_damageVexbuf->Create( 2000, GTH_FORMAT_XYZRHW | GTH_FORMAT_DIFFUSE | GTH_FORMAT_TEXVERTEX(1),
GTH_VERTEX_BUFFER | GTH_DYNAMIC_BUFFER | GTH_WRITEONLY );
for( int i = IF_FONT_DAMAGE_0; i <= IF_FONT_DAMAGE_AVOID; i ++ )
{
m_dmgTexInfo[i].texCoordX = g_ifMng->m_iPos[i].texCoordX;
m_dmgTexInfo[i].texCoordY = g_ifMng->m_iPos[i].texCoordY;
m_dmgTexInfo[i].sizeX = g_ifMng->m_iPos[i].sizeX;
m_dmgTexInfo[i].sizeY = g_ifMng->m_iPos[i].sizeY;
}
}
void CIFNumCtl::Release()
{
if( m_damageVexbuf ) m_damageVexbuf->Release();
GTH_SAFE_DELETE ( m_damageVexbuf );
}
void CIFNumCtl::Render()
{
if ( m_vexCount <= 0 )
return;
int texID;
texID = g_ifMng->m_texInfo[3].texID;
m_pd3dDevice->SetTexture( 0, m_texMng->GetD3DTexture( texID ) );
m_pd3dDevice->SetStreamSource( 0, m_damageVexbuf->GetD3DVertexBuffer(), sizeof(IFTEXTUREVERTEX) );
m_pd3dDevice->SetVertexShader( D3DFVF_IFVERTEX );
m_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, m_vexCount );
m_damageVexbuf->Discard();
}
#define IF_DAMAGE_NUMBER_RENDER_TIME 800
#define IF_DAMAGE_NUMBER_ACCELERATION -0.0001
#define IF_DAMAGE_NUMBER_VELOCITY 0.2
#define IF_DAMAGE_NUMBER_MAX_SIZE 2.0
#define IF_DAMAGE_NUMBER_MIN_SIZE 0.2
#define IF_DAMAGE_NUMBER_VIEW_DISTANCE 2000
void CIFNumCtl::AddDamageNumber( int idx, int type, int attackerIdx, int attackerType, int damage, int stun )
{
int i, n;
for( i = 0; i < MAX_COUNT_IF_DAMAGE_NUMBER; i ++ )
{
if( m_dmgMsg[i].idx < 0 ) break;
}
if( i == MAX_COUNT_IF_DAMAGE_NUMBER ) return;
if( i == m_nDmgMsg ) m_nDmgMsg ++;
n = i;
m_dmgMsg[n].startTime = -1.0f;
m_dmgMsg[n].receiveTime = g_timer.GetAppMilliTime();
m_dmgMsg[n].velocity = (float)IF_DAMAGE_NUMBER_VELOCITY;
m_dmgMsg[n].x = 0.0f;
m_dmgMsg[n].y = 30.0f;
m_dmgMsg[n].type = type;
m_dmgMsg[n].idx = idx;
m_dmgMsg[n].attackerIdx = attackerIdx;
m_dmgMsg[n].attackerType = attackerType;
m_dmgMsg[n].damage = damage;
m_dmgMsg[n].stun = stun;
}
void CIFNumCtl::ReadyDamage( Fx_CHARACTER_t* character )
{
int j;
for( j = 0; j < m_nDmgMsg; j ++ )
{
if( m_dmgMsg[j].idx < 0 ) continue;
if( m_dmgMsg[j].startTime > 0.0f ) continue;
if( m_dmgMsg[j].attackerIdx == character->idxOnServer &&
m_dmgMsg[j].attackerType == character->entityType )
{
m_dmgMsg[j].startTime = g_timer.GetAppMilliTime();
break;
}
}
}
void CIFNumCtl::ReadyDamage( int attackerType, int attackerIdx, int defenderType, int defenderIdx )
{
int j;
for( j = 0; j < m_nDmgMsg; j ++ )
{
if( m_dmgMsg[j].idx < 0 ) continue;
if( m_dmgMsg[j].startTime > 0.0f ) continue;
if( m_dmgMsg[j].attackerIdx == attackerIdx &&
m_dmgMsg[j].attackerType == attackerType )
{
m_dmgMsg[j].startTime = g_timer.GetAppMilliTime();
break;
}
}
}
int CIFNumCtl::CheckHitTarget( int attackerType, int attackerIdx, int defenderType, int defenderIdx )
{
int j;
for( j = 0; j < m_nDmgMsg; j ++ )
{
if( m_dmgMsg[j].idx < 0 ) continue;
if( m_dmgMsg[j].startTime < 0.0f ) continue;
if( m_dmgMsg[j].attackerIdx == attackerIdx &&
m_dmgMsg[j].attackerType == attackerType &&
m_dmgMsg[j].idx == defenderIdx &&
m_dmgMsg[j].type == defenderType )
{
if( m_dmgMsg[j].damage > 0 ) return( 1 );
else return( 0 );
}
}
return( 0 );
}
void CIFNumCtl::ProcessDamage()
{
int i, j, numCharacter;
int alpha = 0xff;
float temp, temp2;
float z, w, dist;
char str[255];
float dmgSize = 0.0f, maxDmgSize;
int len;
int pos;
float x, y, xs, ys, cy;
float tx1, ty1, tx2, ty2;
DWORD color;
D3DXVECTOR3 charPos;
Fx_CHARACTER_t *character;
for( i = 0; i < m_nDmgMsg; i ++ )
{
if( m_dmgMsg[i].idx < 0 ) continue;
if( m_dmgMsg[i].receiveTime + 5000.0f < g_timer.GetAppMilliTime() )
{
m_dmgMsg[i].idx = -1;
continue;
}
if( m_dmgMsg[i].startTime < 0.0f ) continue;
temp = g_timer.GetAppMilliTime() - m_dmgMsg[i].startTime;
temp2 = m_dmgMsg[i].velocity * temp + 0.5f * temp * temp * IF_DAMAGE_NUMBER_ACCELERATION;
m_dmgMsg[i].y = -temp2 + 60.0f;
}
IFTEXTUREVERTEX *pVertices = NULL;
pVertices = (IFTEXTUREVERTEX *)m_damageVexbuf->Lock();
for( i = 0; i < m_nDmgMsg; i ++ )
{
if( m_dmgMsg[i].idx < 0 ) continue;
if( m_dmgMsg[i].startTime < 0.0f ) continue;
character = &g_charManager->m_Characters[0];
numCharacter = g_charManager->m_iNumCharacters;
for ( j = 0; j < numCharacter; j++, character++)
{
if( character->entityType == m_dmgMsg[i].type &&
character->idxOnServer == m_dmgMsg[i].idx )
{
if( character->entityType == ENTITY_MONSTER )
{
color = 0x00ffffff;
} else color = 0x00ff0000;
break;
}
}
if( j >= numCharacter ) continue;
if( character->flag_culled ) continue;
w = g_charManager->GetCharPanelScreenPos( character, charPos );
x = (float)m_dmgMsg[i].x + charPos[0];
y = (float)m_dmgMsg[i].y + charPos[1];
z = (float)charPos[2];
dist = GTH_GetDistance( character->position, g_pApp->m_myCharacter->position );
dist -= g_camera.m_distance;
if( dist > IF_DAMAGE_NUMBER_VIEW_DISTANCE ) dist = IF_DAMAGE_NUMBER_VIEW_DISTANCE;
maxDmgSize = IF_DAMAGE_NUMBER_MIN_SIZE + IF_DAMAGE_NUMBER_MAX_SIZE * ( IF_DAMAGE_NUMBER_VIEW_DISTANCE - dist ) / IF_DAMAGE_NUMBER_VIEW_DISTANCE;
temp = IF_DAMAGE_NUMBER_RENDER_TIME - ( g_timer.GetAppMilliTime() - m_dmgMsg[i].startTime );
if( temp < 0.0f )
{
temp = 0.0f;
m_dmgMsg[i].idx = -1;
continue;
}
alpha = 0xff;
temp = g_timer.GetAppMilliTime() - m_dmgMsg[i].startTime;
temp = temp / ( IF_DAMAGE_NUMBER_RENDER_TIME * 0.1f );
if( temp > 1.0f ) temp = 1.0f;
dmgSize = 0.1f + maxDmgSize * temp;
if( dmgSize > maxDmgSize ) dmgSize = maxDmgSize;
temp = g_timer.GetAppMilliTime() - m_dmgMsg[i].startTime;
if( temp > IF_DAMAGE_NUMBER_RENDER_TIME * 0.5f )
{
temp -= IF_DAMAGE_NUMBER_RENDER_TIME * 0.5f;
temp /= IF_DAMAGE_NUMBER_RENDER_TIME * 0.5f;
temp = 1.0f - temp;
if( temp > 1.0f ) temp = 1.0f;
if( temp < 0.0f ) temp = 0.0f;
if( ( m_dmgMsg[i].attackerIdx == g_cgv.myPCIdxOnServer && m_dmgMsg[i].attackerType == ENTITY_PC ) || \
( m_dmgMsg[i].idx == g_cgv.myPCIdxOnServer && m_dmgMsg[i].type == ENTITY_PC ) ) alpha = (int)( (float)255.0f * temp );
else alpha = (int)( (float)128.0f * temp );
}
if( alpha > 0xff ) alpha = 0xff;
else if( alpha < 0 )
{
m_dmgMsg[i].idx = -1;
alpha = 0;
}
alpha <<= 24;
color = color | alpha;
if( m_dmgMsg[i].damage > 0 )
{
if( m_dmgMsg[i].stun > 0 )
{
if( character->entityType == ENTITY_MONSTER )
{
if( m_dmgMsg[i].stun == 1 ) sprintf( str, "c%d", m_dmgMsg[i].damage );
else sprintf( str, "o%d", m_dmgMsg[i].damage );
}
else
{
sprintf( str, "o%d", m_dmgMsg[i].damage );
}
}
else
{
sprintf( str, "%d", m_dmgMsg[i].damage );
}
} else if( m_dmgMsg[i].damage == 0 )
{
if( character->entityType == ENTITY_MONSTER )
sprintf( str, "m" );
else sprintf( str, "a" );
}
len = strlen( str );
for( j = 0; j < len; j ++ )
{
if( ( str[j] >= '0' && str[j] <= '9' ) )
{
pos = str[j] - '0';
cy = 0.0f;
pos += IF_FONT_DAMAGE_0;
} else
{
cy = 0.0f;
if( str[j] == 'm' )
{
pos = IF_FONT_DAMAGE_MISS;
} else if( str[j] == 'o' )
{
cy = 1.0f;
pos = IF_FONT_DAMAGE_SHOCK;
} else if( str[j] == 'c' )
{
cy = 1.0f;
pos = IF_FONT_DAMAGE_CRITICAL;
} else if( str[j] == 'a' )
{
pos = IF_FONT_DAMAGE_AVOID;
} else continue;
}
ys = (float)m_dmgTexInfo[pos].sizeY;
tx1 = (float)m_dmgTexInfo[pos].texCoordX;
xs = (float)m_dmgTexInfo[pos].sizeX;
ty1 = (float)m_dmgTexInfo[pos].texCoordY;
if( cy > 0.0f ) cy = ( ys * 1.2f ) * maxDmgSize;
tx2 = tx1 + xs;
ty2 = ty1 + ys;
tx1 /= 256.0f;
ty1 /= 128.0f;
tx2 /= 256.0f;
ty2 /= 128.0f;
xs *= dmgSize;
ys *= dmgSize;
if( j == 0 )
{
x -= xs / 2;
y -= ys * maxDmgSize;
}
cy = y - cy;
float tempzpos = z;
float tempwpos = w;
pVertices[m_nDamageVex].position = D3DXVECTOR4( x - 0.5f, cy + ys - 0.5f, tempzpos, tempwpos );
pVertices[m_nDamageVex].color = color;
pVertices[m_nDamageVex].tu = tx1;
pVertices[m_nDamageVex].tv = ty2;
m_nDamageVex ++;
pVertices[m_nDamageVex].position = D3DXVECTOR4( x - 0.5f, cy - 0.5f, tempzpos, tempwpos );
pVertices[m_nDamageVex].color = color;
pVertices[m_nDamageVex].tu = tx1;
pVertices[m_nDamageVex].tv = ty1;
m_nDamageVex ++;
pVertices[m_nDamageVex].position = D3DXVECTOR4( x + xs - 0.5f, cy + ys - 0.5f, tempzpos, tempwpos );
pVertices[m_nDamageVex].color = color;
pVertices[m_nDamageVex].tu = tx2;
pVertices[m_nDamageVex].tv = ty2;
m_nDamageVex ++;
pVertices[m_nDamageVex].position = D3DXVECTOR4( x + xs - 0.5f, cy - 0.5f, tempzpos, tempwpos );
pVertices[m_nDamageVex].color = color;
pVertices[m_nDamageVex].tu = tx2;
pVertices[m_nDamageVex].tv = ty1;
m_nDamageVex ++;
pVertices[m_nDamageVex].position = D3DXVECTOR4( x + xs - 0.5f, cy + ys - 0.5f, tempzpos, tempwpos );
pVertices[m_nDamageVex].color = color;
pVertices[m_nDamageVex].tu = tx2;
pVertices[m_nDamageVex].tv = ty2;
m_nDamageVex ++;
pVertices[m_nDamageVex].position = D3DXVECTOR4( x - 0.5f, cy - 0.5f, tempzpos, tempwpos );
pVertices[m_nDamageVex].color = color;
pVertices[m_nDamageVex].tu = tx1;
pVertices[m_nDamageVex].tv = ty1;
m_nDamageVex ++;
m_nNumDamage += 2;
if( ( str[j] >= '0' && str[j] <= '9' ) ) x += xs + 1.0f;
}
}
m_damageVexbuf->Unlock();
m_vexCount = m_nNumDamage;
m_nDamageVex = 0;
m_nNumDamage = 0;
}
| C++ |
#include "../global_def.h"
#include "IFCommon.h"
CIFHyperLink::CIFHyperLink( CIFControlNode *pParentControl ) : CIFControlNode( pParentControl )
{
m_enable = true;
m_rootLinkNode = NULL;
m_pointLinkIndex = -1;
m_startLine = 0;
m_maxLineCount = 0;
m_viewLineCount = 0;
m_str[0] = 0;
}
CIFHyperLink::~CIFHyperLink()
{
ClearAllLinkNode();
}
void CIFHyperLink::PrepareControl( int id )
{
float px, py;
int pID = -1, cID;
int tsizex, tsizey;
m_info.ID = id;
px = 0.0f;
py = 0.0f;
cID = id;
pID = g_ifMng->m_iPos[cID].parentID;
m_info.parentID = pID;
tsizex = m_info.sizeX = g_ifMng->m_iPos[id].sizeX;
tsizey = m_info.sizeY = g_ifMng->m_iPos[id].sizeY;
while( pID >= 0 )
{
px += g_ifMng->m_iPos[pID].clientX;
py += g_ifMng->m_iPos[pID].clientY;
cID = pID;
pID = g_ifMng->m_iPos[cID].parentID;
}
m_info.clientX = g_ifMng->m_iPos[id].clientX + (int)px;
m_info.clientY = g_ifMng->m_iPos[id].clientY + (int)py;
}
void CIFHyperLink::UpdateControl()
{
float px, py;
int pID = -1, cID;
px = 0.0f;
py = 0.0f;
cID = m_info.ID;
pID = g_ifMng->m_iPos[cID].parentID;
while( pID >= 0 )
{
px += g_ifMng->m_iPos[pID].clientX;
py += g_ifMng->m_iPos[pID].clientY;
cID = pID;
pID = g_ifMng->m_iPos[cID].parentID;
}
cID = m_info.ID;
m_info.clientX = g_ifMng->m_iPos[cID].clientX + (int)px;
m_info.clientY = g_ifMng->m_iPos[cID].clientY + (int)py;
CIFControlNode::UpdateControl();
}
int CIFHyperLink::Selection()
{
int x1, y1, x2, y2;
int mx, my;
x1 = m_info.clientX;
y1 = m_info.clientY;
x2 = m_info.clientX + m_info.sizeX;
y2 = m_info.clientY + m_info.sizeY;
mx = g_input->GetPosX();
my = g_input->GetPosY();
if( x1 <= mx && x2 >= mx && y1 <= my && y2 >= my )
{
if( g_input->GetLBDown() ) return( IF_LBDN );
else if( g_input->GetRBDown() ) return( IF_RBDN );
else if( g_input->GetLBUp() ) return( IF_LBUP );
else if( g_input->GetRBUp() ) return( IF_RBUP );
else if( g_input->GetLBKeep() ) return( IF_LBKEEP );
else if( g_input->GetRBKeep() ) return( IF_RBKEEP );
else return( IF_IN_POS );
}
return( IF_NOT_IN_POS );
}
int CIFHyperLink::PointInLink()
{
if( m_rootLinkNode == NULL)
{
m_pointLinkIndex = -1;
return -1;
}
linkNode_t *node = m_rootLinkNode;
int mx, my;
int linkIndex = 0;
mx = g_input->GetPosX() - m_info.clientX;
my = g_input->GetPosY() - m_info.clientY + m_startLine*13;
while( node != NULL )
{
if( node->top >= m_startLine*13 )
{
if( node->left <= mx && node->right >= mx && node->top <= my && node->bottom >= my )
{
m_pointLinkIndex = linkIndex;
if ( g_input->GetLBUp() )
return node->linkNumber;
else
return -1;
}
linkIndex++;
}
node = node->next;
}
m_pointLinkIndex = -1;
return -1;
}
void CIFHyperLink::AddLinkNode( linkNode_t *node )
{
linkNode_t *newNode = new linkNode_t;
linkNode_t *tempNode = m_rootLinkNode;
newNode->next = NULL;
memcpy( &newNode->left, &node->left, sizeof(int)*4 );
newNode->linkNumber = node->linkNumber;
if( m_rootLinkNode == NULL )
{
m_rootLinkNode = newNode;
return;
}
else
{
while( tempNode->next != NULL )
tempNode = tempNode->next;
tempNode->next = newNode;
}
}
void CIFHyperLink::ClearAllLinkNode()
{
if( m_rootLinkNode == NULL) return;
linkNode_t *node = m_rootLinkNode;
linkNode_t *next = NULL;
while( node != NULL )
{
next = node->next;
delete node;
node = next;
}
m_rootLinkNode = NULL;
}
void CIFHyperLink::SetText( char *str )
{
int texIdx;
int tx1, tx2, ty1, ty2;
int rx = 0, ry = 0;
bool bLinkStart = false;
linkNode_t node;
wchar_t uniCode;
unsigned char aniCode[3];
char buffer[4];
bool bDoubleByte = false;
int xs = m_info.sizeX;
int ys = m_info.sizeY;
strcpy( m_str, str );
ClearAllLinkNode();
m_startLine = 0;
m_maxLineCount = 0;
m_viewLineCount = 0;
if ( *str == NULL )
return;
m_maxLineCount = 1;
while( *str )
{
memset( aniCode, 0, sizeof( aniCode ) );
memset( buffer, 0, sizeof( buffer ) );
aniCode[0] = *str;
tx1 = ty1 = tx2 = ty2 = 0;
texIdx = -1;
if( aniCode[0] == '&' )
{
aniCode[1] = * ++str;
if ( aniCode[1] == 's' )
{
memset( &node, 0, sizeof(node) );
node.linkNumber = -1;
node.left = rx;
node.top = ry;
bLinkStart = true;
}
else if ( aniCode[1] == 'e' )
{
node.right = rx;
node.bottom = ry + 13;
if( bLinkStart && node.linkNumber != -1 )
{
bLinkStart = false;
AddLinkNode( &node );
}
memset( &node, 0, sizeof(node) );
node.linkNumber = -1;
}
else if ( aniCode[1] == 'l' )
{
buffer[0] = * ++str;
buffer[1] = * ++str;
buffer[2] = * ++str;
buffer[3] = 0;
if( bLinkStart )
{
node.linkNumber = atoi( buffer );
}
}
else if( aniCode[1] == 'n' )
{
if (bLinkStart)
{
node.right = xs;
node.bottom = ry + 13;
AddLinkNode( &node );
bLinkStart = false;
}
m_maxLineCount++;
ry += 13;
rx = 0;
}
}
else if( aniCode[0] == ' ' )
{
tx1 = 0;
tx2 = 6;
}
else
{
if( IsDBCSLeadByte( (BYTE)aniCode[0] ) )
{
aniCode[1] = * ++str;
aniCode[2] = 0;
bDoubleByte = true;
}
else
{
aniCode[1] = 0;
}
MultiByteToWideChar( CP_ACP, MB_COMPOSITE, (char*)aniCode, -1, &uniCode, 1 );
texIdx = g_chatManager->FindTexIdx( uniCode );
}
if( texIdx >= 0 )
{
tx1 = g_chatManager->GetHanTexCoord(texIdx)->tx1;
ty1 = g_chatManager->GetHanTexCoord(texIdx)->ty1;
tx2 = g_chatManager->GetHanTexCoord(texIdx)->tx2;
ty2 = g_chatManager->GetHanTexCoord(texIdx)->ty2;
}
str ++;
rx += tx2 - tx1;
if( rx > xs )
{
if (bLinkStart)
{
node.right = xs;
node.bottom = ry + 13;
AddLinkNode( &node );
bLinkStart = false;
}
if (bDoubleByte)
str -= 2;
else
str --;
m_maxLineCount++;
rx = 0;
ry += 13;
}
if( ry <= ys )
{
m_viewLineCount = m_maxLineCount;
}
}
}
void CIFHyperLink::SetColor( DWORD color )
{
m_color = color;
}
void CIFHyperLink::Render( int renderType )
{
if( !State() ) return;
if( m_str[0] == 0 ) return;
int x, y, xs, ys;
x = m_info.clientX;
y = m_info.clientY;
xs = m_info.sizeX;
ys = m_info.sizeY;
g_chatManager->SetColor( m_color );
g_chatManager->SetColor( 0xffffffff );
g_chatManager->DrawTextRectLineScroll( x, y, m_str, xs, ys, m_startLine, m_pointLinkIndex );
}
| C++ |
#include <windows.h>
#include <basetsd.h>
#include <tchar.h>
#include "global_def.h"
#include "resource.h"
#include "GTH.h"
int GTH::ChangeStartProcessBefore()
{
return S_OK;
}
int GTH::ChangeStartProcessAfter()
{
if ( g_cgv.restartState != RESTART_NONE )
{
g_ifMng->RestartInterface( 0 );
InitApp();
RestoreApp();
}
g_charManager->m_drawShadows = false;
return S_OK;
}
int GTH::RestoreStartProcess()
{
int i;
vec3_t delta;
g_d3dRender.InitDevice();
g_chatManager->SetDevice( m_pd3dDevice );
g_chatManager->CreateFont();
g_chatManager->InitInput();
g_ifMng->SetDevice( m_pd3dDevice );
g_ifMng->PrepareAllControl( m_d3dsdBackBuffer.Width, m_d3dsdBackBuffer.Height );
g_ifMng->RestoreDeviceObjects();
m_MDLMng->SetDevice( m_pd3dDevice );
for( i = 0 ; i < m_numWorldBSPs ; i++ )
{
m_worldBSPs[ i ]->Restore();
}
m_MDLMng->Restore( m_pd3dDevice );
g_charManager->SetDevice( m_pd3dDevice );
g_charManager->PrepareBuffers();
g_charManager->UpdateCharacterState();
g_charManager->RestoreDeviceObject();
g_texMng.Restore();
g_charManager->m_Characters[0].position[0] = -3.0f;
g_charManager->m_Characters[0].position[1] = -411.0f;
g_charManager->m_Characters[0].position[2] = -900.0f;
g_charManager->m_Characters[0].angles[0] = -22.0f;
g_charManager->m_Characters[0].angles[1] = 90.0f;
g_charManager->m_Characters[0].angles[2] = 0.0f;
m_myCharacter = &g_charManager->m_Characters[0];
g_camera.m_angles[ YAW ] = m_myCharacter->angles[ YAW ];
VectorClear( delta );
g_entityMng->ActivateCameraPath( "cam_start" , "cam_start" , GTH_ENTITY_PLAY_FORWARD );
g_input->Center();
g_camera.m_projectParm.aspect = (float) m_d3dsdBackBuffer.Width / (float) m_d3dsdBackBuffer.Height;
g_camera.SetProjectParameter( GTH_PROJECT_NEAR_PLANE , m_worldBSPs[0]->m_visibleDist );
D3DXMatrixPerspectiveFovLH( (D3DXMATRIX*)&g_camera.m_projMat , deg2rad( g_camera.m_projectParm.fov / g_camera.m_projectParm.aspect )
, g_camera.m_projectParm.aspect , g_camera.m_projectParm.znear , g_camera.m_projectParm.zfar );
g_camera.SetupViewPort( 0 , 0 , m_d3dsdBackBuffer.Width , m_d3dsdBackBuffer.Height
, g_camera.m_projectParm.znear , g_camera.m_projectParm.zfar );
g_cursor->SetupViewPort( 0 , 0 , m_d3dsdBackBuffer.Width , m_d3dsdBackBuffer.Height
, g_camera.m_projectParm.znear , g_camera.m_projectParm.zfar );
g_timeSystem->SetFogParameter(m_mapInfos[ 0 ].fogColor,
m_mapInfos[ 0 ].fogStart,
m_mapInfos[ 0 ].fogEnd,
g_camera.m_projectParm.znear,
g_camera.m_projectParm.zfar);
return S_OK;
}
int GTH::InitStartProcess()
{
int i, ret;
LoadConfig( "select.cfg" );
if(m_mapInfos[0].fogColor)
g_timeSystem->SetFogEnable();
else
g_timeSystem->SetFogDisable();
for( i = 0 ; i < m_numMapInfos ; i++ )
{
ret = LoadMap( m_mapInfos[ i ].mapName );
if( !ret ) return false;
}
g_move->SetWorldModel( m_worldBSPs[ m_currWorld ] );
g_entityMng->SetWorldModel( m_worldBSPs[ m_currWorld ] );
g_itemMng->SetWorldModel( m_worldBSPs[ m_currWorld ] );
g_effectMng->SetWorldModel( m_worldBSPs[ m_currWorld ] );
g_cursor->SetWorldModel( m_worldBSPs[ m_currWorld ] );
g_camera .SetWorldModel ( m_worldBSPs[ m_currWorld ] );
ret = LoadMDLClasses( &m_mapInfos[0] );
if( !ret ) return false;
ret = LoadEntity( m_mapInfos[0].objectName );
if( !ret ) return false;
for( i = 0 ; i < m_numWorldBSPs ; i++ )
m_worldBSPs[ i ]->Initialize( m_mapInfos[ 0 ].worldVisible );
g_entityMng->Initialize( m_mapInfos[ 0 ].modelVisible );
g_itemMng->Initialize( m_mapInfos[ 0 ].itemVisible );
g_effectMng->Initialize( m_mapInfos[ 0 ].itemVisible );
g_cursor->Initialize();
m_MDLMng->Initialize();
g_camera.Reset();
m_frameFlag = 0;
return( S_OK );
}
int GTH::StartProcessFrame()
{
check.time0 = check.timer.Tick();
if( m_frameFlag )
{
if( FAILED( BeginScene() ) )
return E_FAIL;
ApplyTimeEnv();
check.time1 = check.timer.Tick();
WorldRenderBefore();
check.time2 = check.timer.Tick();
CharacterFrame();
check.time3 = check.timer.Tick();
EntityFrame();
check.time4 = check.timer.Tick();
WorldRenderAfter();
check.time5 = check.timer.Tick();
CursorFrame();
g_ifMng->PrepareRender();
g_ifMng->Render();
RenderText();
g_chatManager->Render();
}
check.time6 = check.timer.Tick();
g_entityMng->Process( m_myCharacter->position , g_camera.m_position , m_frameFlag , g_camera.m_distance );
g_itemMng->Process( g_camera.m_position , m_frameFlag );
g_effectMng->Process( g_camera.m_position , m_frameFlag );
switch( AppProcess() )
{
case false :
break;
case 2 :
if( m_frameFlag )
EndScene();
return E_FAIL;
}
check.time7 = check.timer.Tick();
WorldFrame();
check.time8 = check.timer.Tick();
if( m_frameFlag )
{
check.time9 = check.timer.Tick();
EndScene();
check.time10 = check.timer.Tick();
}
m_frameFlag++;
return S_OK;
}
int GTH::StartProcess()
{
POINT p;
g_charManager ->StartFrame ();
g_charManager ->UpdateAnimations();
g_input->GetCursorPos( p );
if( g_ifMng->ProcessInterface() == IF_CTL_EVENT ) ChangeClientState( CLIENT_LOGIN_PROCESS );
#ifdef _GTH_ONLINE_VERSION
if (g_cgv.onMasterServer)
{
GTH_MasterServer();
}
#endif
GetKeyState();
g_camera.SetupMatrices( true );
return true;
}
| C++ |
#include <windows.h>
#include <basetsd.h>
#include <tchar.h>
#include "global_def.h"
#include "resource.h"
#include "GTH.h"
int GTH::ChangeLoadingProcessBefore()
{
g_ifMng->InvalidateDeviceObjects();
g_chatManager->InvalidateFont();
g_texMng.Release();
GTH_EnableMove();
g_charManager->m_drawShadows = !g_userConfig.shadow;
return true;
}
int GTH::ChangeLoadingProcessAfter()
{
InitApp();
RestoreApp();
g_ifMng->m_dlgWin->SetDlgInput( false );
return true;
}
int GTH::RestoreLoadingProcess()
{
g_chatManager->SetDevice( m_pd3dDevice );
g_chatManager->CreateFont();
g_ifMng->SetDevice( m_pd3dDevice );
g_ifMng->PrepareAllControl( m_d3dsdBackBuffer.Width, m_d3dsdBackBuffer.Height );
g_ifMng->RestoreDeviceObjects();
g_texMng.Restore();
if ( g_cgv.changeServerFlag )
{
#ifdef _GTH_ONLINE_VERSION
GTH_SendMessage_ConnectGameServer();
#endif
}
return true;
}
int GTH::InitLoadingProcess()
{
return true;
}
int GTH::LoadingProcessFrame()
{
check.time0 = check.timer.Tick();
if( FAILED( BeginScene() ) )
return E_FAIL;
g_chatManager->Render();
g_ifMng->PrepareRender();
g_ifMng->Render();
if( !AppProcess() ) return E_FAIL;
EndScene();
return true;
}
int GTH::LoadingProcess()
{
switch( g_ifMng->ProcessInterface() )
{
case IF_CTL_EVENT :
{
ChangeClientState( CLIENT_GAME_PROCESS );
return( 1 );
}
break;
}
#ifdef _GTH_ONLINE_VERSION
if (g_cgv.onGameServer) GTH_ListenPacket();
#endif
return true;
}
| C++ |
#include <windows.h>
#include "unpak.h"
int PackFileOpen (packfile_t *pf, const char *zname)
{
int x, max;
unz_file_info file_info;
strcpy (pf->pak_name, zname);
pf->uf = unzOpen (pf->pak_name);
if (!pf->uf)
{
return ERROR_PACK_FILE_NOT_EXIST;
}
unzGetGlobalInfo (pf->uf, &pf->gi);
pf->fi = (fileinfo_t *)malloc (sizeof(fileinfo_t)*pf->gi.number_entry);
if (!pf->fi)
{
unzClose (pf->uf);
return ERROT_NOT_ENOUGHT_MEMORY;
}
max = pf->gi.number_entry;
for (x=0; x<max; x++)
{
unzGetCurrentFileInfo (pf->uf,&file_info, pf->fi[x].name,sizeof(pf->fi[x].name),NULL,0,NULL,0);
pf->fi[x].attr = file_info.external_fa;
pf->fi[x].offset = file_info.offset;
pf->fi[x].size = file_info.uncompressed_size;
pf->fi[x].c_offset = file_info.c_offset;
pf->fi[x].date = file_info.dosDate;
_strlwr( pf->fi[x].name );
unzGoToNextFile (pf->uf);
}
return 1;
}
void PackFileClose (packfile_t *pf)
{
if ( ! pf->uf )
return;
if (pf->fi)
{
free (pf->fi);
pf->fi = NULL;
}
if (pf->uf)
{
unzClose (pf->uf);
pf->uf = NULL;
}
}
int PackFileGetFileWithName (packfile_t *pf, char *fname, char **buf)
{
int num;
DWORD err;
for (num = 0; num<(int)pf->gi.number_entry; num++)
{
if (!stricmp(fname, pf->fi[num].name)) break;
}
if (num >= (int)pf->gi.number_entry)
return ERROR_FILE_NOT_EXIST;
*buf = (char *)malloc (pf->fi[num].size);
unzLocateFileMy (pf->uf, num, pf->fi[num].c_offset);
unzOpenCurrentFile (pf->uf);
err = unzReadCurrentFile (pf->uf,*buf,pf->fi[num].size);
unzCloseCurrentFile (pf->uf);
if (err!=pf->fi[num].size)
{
free (*buf);
*buf = NULL;
return ERROR_FILE_NOT_EXTRACTED;
}
return pf->fi[num].size;
}
int PackFileGetFileWithIndex (packfile_t *pf, int idx , char **buf)
{
DWORD err;
if (idx >= (int)pf->gi.number_entry)
return ERROR_FILE_NOT_EXIST;
*buf = (char *)malloc (pf->fi[idx].size);
unzLocateFileMy (pf->uf, idx, pf->fi[idx].c_offset);
unzOpenCurrentFile (pf->uf);
err = unzReadCurrentFile (pf->uf,*buf,pf->fi[idx].size);
unzCloseCurrentFile (pf->uf);
if (err!=pf->fi[idx].size)
{
free (*buf);
*buf = NULL;
return ERROR_FILE_NOT_EXTRACTED;
}
return pf->fi[idx].size;
}
int PackFileGetEntrySize (packfile_t *pf)
{
return pf->gi.number_entry;
}
char *PackFileGetFileName (packfile_t *pf, int num)
{
if (num >= (int)pf->gi.number_entry) return NULL;
return pf->fi[num].name;
}
uLong PackFileGetFileSizeWithName( packfile_t *pf , char *fname )
{
int num;
for (num = 0; num<(int)pf->gi.number_entry; num++)
{
if (!stricmp(fname, pf->fi[num].name)) break;
}
if (num >= (int)pf->gi.number_entry)
return ERROR_FILE_NOT_EXIST;
return pf->fi[num].size;
}
uLong PackFileGetFileSizeWithIndex( packfile_t *pf , int idx )
{
if (idx >= (int)pf->gi.number_entry)
return ERROR_FILE_NOT_EXIST;
return pf->fi[idx].size;
}
int PackFileSearchFile( packfile_t *pf , char *fname )
{
if ( ! pf->uf )
return ERROR_FILE_NOT_EXIST;
int num;
for (num = 0; num<(int)pf->gi.number_entry; num++)
{
if (!stricmp(fname, pf->fi[num].name)) break;
}
if (num >= (int)pf->gi.number_entry)
return ERROR_FILE_NOT_EXIST;
return num;
}
int PackFileSearchRecentFile ( packfile_t *pf,
char *fname )
{
if ( ! pf->uf )
return ERROR_FILE_NOT_EXIST;
int recent = -1;
int num;
for ( num = 0; \
num < (int)pf->gi.number_entry; \
++num )
{
if ( ! stricmp( fname, pf->fi[ num ].name ) )
break;
}
if ( num >= (int)pf->gi.number_entry )
return ERROR_FILE_NOT_EXIST;
recent = num;
for ( ; \
num < (int)pf->gi.number_entry; \
++num )
{
if ( ! stricmp( fname, pf->fi[ num ].name ) )
{
if ( pf->fi[ recent ].date < pf->fi[ num ].date )
{
recent = num;
}
}
}
return recent;
}
char *GetFileExt( char *fname );
int PackFileSearchFilesExt( packfile_t *pf , char *ext , int pack , packsearch_t *list )
{
if ( ! pf->uf )
return 0;
unsigned long i;
int numFound;
char *extention;
numFound = 0;
for( i = 0 ; i < pf->gi.number_entry ; i++ )
{
extention = GetFileExt( pf->fi[i].name );
if( !extention ) continue;
if( !stricmp( extention , ext ) )
{
list[ numFound ].pack = pack;
list[ numFound ].entry = i;
list[ numFound ].size = pf->fi[i].size;
list[ numFound ].date = pf->fi[i].date;
strcpy( list[ numFound++ ].name , pf->fi[i].name );
}
}
return numFound;
}
char *GetFileExt( char *fname )
{
int i , found;
int pathLen = strlen( fname );
found = 0;
for( i = 0 ; i < pathLen ; i++ )
{
if( fname[i] == '.' )
{
found = i;
break;
}
}
if( found ) return fname + found + 1;
else return NULL;
} | C++ |
#include <windows.h>
#include <basetsd.h>
#include <tchar.h>
#include "global_def.h"
#include "resource.h"
#include "GTH.h"
#include "../game/GolryunBattle/GolryunBattle.h"
int GTH::ChangeGameProcessBefore()
{
int i;
g_chatManager->InvalidateFont();
g_ifMng->InvalidateDeviceObjects();
for( i = 0 ; i < m_numWorldBSPs ; i++ )
{
m_worldBSPs[ i ]->Release();
GTH_SAFE_DELETE( m_worldBSPs[ i ] );
}
m_numWorldBSPs = 0;
if( m_MDLMng )
m_MDLMng->Release();
GTH_SAFE_DELETE( m_MDLMng );
g_shaderMng.Release();
g_modelShaderMng->Release();
g_charShaderMng->Release();
g_charManager->ReleaseBuffers();
g_timeSystem->InvalidateDeviceObjects();
g_texMng.Release();
g_musicMng->StopBGMusic();
g_musicMng->Stop();
g_musicMng->Stop( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_PC_HEARTBEAT_0 ) );
g_ifMng->m_renderLoadingFlag = false;
return true;
}
int GTH::ChangeGameProcessAfter()
{
InitApp();
RestoreApp();
InitCharacter();
g_ifMng->m_dlgWin->SetDlgInput( true );
g_cgv.missSyncTimeCount --;
g_cgv.flagChangeWorld = false;
g_itemMng->m_MDLMng->SetFocusItemUsage( false );
return true;
}
int GTH::RestoreGameProcess()
{
int i;
g_chatManager->SetDevice( m_pd3dDevice );
g_chatManager->CreateFont();
g_ifMng->SetDevice( m_pd3dDevice );
g_ifMng->PrepareAllControl( m_d3dsdBackBuffer.Width, m_d3dsdBackBuffer.Height );
g_ifMng->RestoreDeviceObjects();
m_MDLMng->SetDevice( m_pd3dDevice );
for( i = 0 ; i < m_numWorldBSPs ; i++ )
m_worldBSPs[ i ]->Restore();
m_MDLMng->Restore( m_pd3dDevice );
g_charManager->SetDevice( m_pd3dDevice );
g_charManager->PrepareBuffers();
g_charManager->UpdateCharacterState();
g_charManager->RestoreDeviceObject();
g_timeSystem->InitDeviceObjects();
g_timeSystem->RestoreDeviceObjects();
g_texMng.Restore();
g_ifMng->InitSoundVolume();
g_musicMng->PlayBGMusic( m_mapInfos[ 0 ].BGMusic );
g_camera.m_projectParm.aspect = (float) m_d3dsdBackBuffer.Width / (float) m_d3dsdBackBuffer.Height;
g_camera.SetProjectParameter(GTH_PROJECT_NEAR_PLANE,
m_worldBSPs[0]->m_visibleDist);
D3DXMatrixPerspectiveFovLH((D3DXMATRIX*)&g_camera.m_projMat,
deg2rad( g_camera.m_projectParm.fov / g_camera.m_projectParm.aspect ),
g_camera.m_projectParm.aspect,
g_camera.m_projectParm.znear,
50000.0f);
g_camera.SetupViewPort(0,
0,
m_d3dsdBackBuffer.Width,
m_d3dsdBackBuffer.Height,
g_camera.m_projectParm.znear,
50000.0f);
g_cursor->SetupViewPort(0,
0,
m_d3dsdBackBuffer.Width,
m_d3dsdBackBuffer.Height,
g_camera.m_projectParm.znear,
50000.0f);
g_timeSystem->SetFogParameter(m_mapInfos[ 0 ].fogColor,
m_mapInfos[ 0 ].fogStart,
m_mapInfos[ 0 ].fogEnd,
g_camera.m_projectParm.znear,
g_camera.m_projectParm.zfar);
return true;
}
int GTH::InitGameProcess()
{
int i, ret;
LoadConfig( g_cgv.worldInfo );
if(m_mapInfos[0].fogColor)
g_timeSystem->SetFogEnable();
else
g_timeSystem->SetFogDisable();
for( i = 0 ; i < m_numMapInfos ; i++ )
{
ret = LoadMap( m_mapInfos[ i ].mapName );
if( !ret ) return false;
}
g_move->SetWorldModel( m_worldBSPs[ m_currWorld ] );
g_entityMng->SetWorldModel( m_worldBSPs[ m_currWorld ] );
g_itemMng->SetWorldModel( m_worldBSPs[ m_currWorld ] );
g_effectMng->SetWorldModel( m_worldBSPs[ m_currWorld ] );
g_cursor->SetWorldModel( m_worldBSPs[ m_currWorld ] );
g_camera.SetWorldModel ( m_worldBSPs[ m_currWorld ] );
ret = LoadMDLClasses( &m_mapInfos[0] );
if( !ret ) return false;
ret = LoadEntity( m_mapInfos[0].objectName );
if( !ret ) return false;
for( i = 0 ; i < m_numWorldBSPs ; i++ )
m_worldBSPs[ i ]->Initialize( m_mapInfos[ 0 ].worldVisible );
g_entityMng->Initialize( m_mapInfos[ 0 ].modelVisible );
g_itemMng->Initialize( m_mapInfos[ 0 ].itemVisible );
g_effectMng->Initialize( m_mapInfos[ 0 ].effectVisible );
g_cursor->Initialize();
m_MDLMng->Initialize();
m_MDLMng ->BindSoundSample ();
g_camera.Reset();
m_frameFlag = 0;
g_TutorialMng->Initialize();
return true;
}
int GTH::GameProcessFrame()
{
check.time0 = check.timer.Tick();
if ( m_worldBSPs[ m_currWorld ] )
{
m_worldBSPs[ m_currWorld ]->SetvisibleQuality( g_userConfig.vision );
}
g_entityMng->SetvisibleQuality( g_userConfig.vision );
g_TutorialMng->Process();
if( m_frameFlag == 2 )
{
GTH_SendMessage_ReadyToPlay();
if ( g_ifMng->m_boothWin->State() )
g_ifMng->m_boothWin->Enable(FALSE);
if ( g_ifMng->m_stackWin->State() )
{
g_ifMng->m_stackWin->m_saveInvenPos = -1;
g_ifMng->m_stackWin->m_saveItemPrice = 0;
g_ifMng->m_stackWin->m_stackType = -1;
g_ifMng->m_stackWin->Enable(FALSE);
}
}
if( m_frameFlag )
{
if( FAILED( BeginScene() ) )
{
return E_FAIL;
}
ApplyTimeEnv();
check.time1 = check.timer.Tick();
WorldRenderBefore();
check.time2 = check.timer.Tick();
CharacterFrame();
check.time3 = check.timer.Tick();
EntityFrame();
check.time4 = check.timer.Tick();
WorldRenderAfter();
check.time5 = check.timer.Tick();
CursorFrame();
g_ifMng->RenderChar();
g_ifMng->PrepareRender();
g_ifMng->Render();
g_chatManager->Render();
RenderText();
g_timeSystem->Render();
}
check.time6 = check.timer.Tick();
vec3_t forward;
g_camera.GetFwdVector( forward );
g_musicMng ->UpdateListener ( m_myCharacter ->position, NULL, forward );
g_entityMng->Process( m_myCharacter->position , g_camera.m_position , m_frameFlag , g_camera.m_distance );
g_itemMng->Process( g_camera.m_position , m_frameFlag );
g_effectMng->Process( g_camera.m_position , m_frameFlag );
switch( AppProcess() )
{
case false :
if( m_frameFlag )
EndScene();
return E_FAIL;
break;
case 2 :
if( m_frameFlag )
EndScene();
return E_FAIL;
}
check.time7 = check.timer.Tick();
WorldFrame();
check.time8 = check.timer.Tick();
if( m_frameFlag )
{
check.time9 = check.timer.Tick();
EndScene();
check.time10 = check.timer.Tick();
}
m_frameFlag++;
extern int g_viewSide;
if( g_viewSide == 1 )
{
g_camera.m_angles[ YAW ] += 90.0f;
g_camera.SetupMatrices( false );
g_camera.m_angles[ YAW ] -= 90.0f;
g_camera.SetupVectors();
}
else if( g_viewSide == 2 )
{
g_camera.m_angles[ YAW ] += 180.0f;
g_camera.SetupMatrices( false );
g_camera.m_angles[ YAW ] -= 180.0f;
g_camera.SetupVectors();
}
else if( g_viewSide == 3 )
{
g_camera.m_angles[ YAW ] -= 90.0f;
g_camera.SetupMatrices( false );
g_camera.m_angles[ YAW ] += 90.0f;
g_camera.SetupVectors();
}
return true;
}
int GTH::GameProcess()
{
g_charManager->StartFrame ();
g_charManager->UpdateAnimations();
#ifndef _GTH_NO_INTERFACE
if( g_ifMng->ProcessSelection() )
{
if( g_input->GetMouseMode() != INPUT_MOUSE_SCROLL_MODE ) g_input->SetMouseMode( INPUT_MOUSE_INTERFACE_MODE );
}
else
{
if( g_input->GetMouseMode() != INPUT_MOUSE_SCROLL_MODE ) g_input->SetMouseMode( INPUT_MOUSE_NORMAL_MODE );
}
#endif
switch( g_ifMng->ProcessInterface() )
{
case IF_CTL_EVENT :
ChangeClientState( CLIENT_LOADING_PROCESS );
return( 2 );
break;
case IF_CTL_EXIT :
GTH_ReturnMasterServer( g_cgv.restartState );
ChangeClientState( CLIENT_START_PROCESS );
return( 2 );
break;
}
FrameMove();
g_ifMng->ProcessIFKeyState();
extern int g_freeMove;
if( g_freeMove )
{
if( FAILED( FreeMove() ) )
return false;
}
else
SetupViewWithKey();
#ifdef _GTH_ONLINE_VERSION
if (g_cgv.onGameServer)
{
GTH_SendMyCharacterEvent();
GTH_MyCharacter_UpdatePosition();
GTH_ListenPacket();
}
#endif
GTH_ExecuteCharacterEvent();
GTH_ServerShutdownTimer();
SetupView();
switch(g_GolryunBattle.GetObserverMode())
{
case CGolryunBattle::eObserverMode::general:
if ( g_freeMove == FALSE)
SetupCamera();
break;
case CGolryunBattle::eObserverMode::observe:
g_GolryunBattle.SetupObserver();
break;
}
float heartbeat = 1.0f;
if( m_myCharacter->calMaxRA > 0 && m_myCharacter->curRA > 0 )
{
heartbeat = (float)m_myCharacter->curRA / (float)m_myCharacter->calMaxRA;
if( heartbeat <= 0.2f )
{
if( !g_musicMng->IsPlaying( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_PC_HEARTBEAT_0 ) ) )
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_PC_HEARTBEAT_0 ), GTH_SOUND_PLAY_ONCE );
}
}
if( heartbeat > 0.2f )
{
if( g_musicMng->IsPlaying( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_PC_HEARTBEAT_0 ) ) )
g_musicMng->Stop( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_PC_HEARTBEAT_0 ) );
}
g_timeSystem->FrameMove();
return true;
}
| C++ |
#include "global_def.h"
#include "CTools.h"
CTools gcTools;
CTools::CTools()
{
m_bOK=FALSE;
m_bOK=TRUE;
}
CTools::~CTools()
{
}
BOOL CTools::isOK(void) const
{
return m_bOK;
}
void CTools::Replace_singleQUOTATIONmark_by_doubleQUOTATIONmark(char* ntspString)
{
for(char* pPos=ntspString;NULL != *pPos; pPos++){
if(*pPos == '\'') *pPos='\"';
}
}
void CTools::Replace_doubleQUOTATIONmark_by_singleQUOTATIONmark(char* ntspString)
{
for(char* pPos=ntspString;NULL != *pPos; pPos++){
if(*pPos == '\"') *pPos='\'';
}
}
int CTools::GetEpkChargeCount(item_t *pItem)
{
return pItem->optionValue[item_t::ITEM_T_CHARGE_VALUE];
}
void CTools::SetEpkChargeCount(item_t *pItem,int count)
{
pItem->optionIdx[item_t::ITEM_T_CHARGE_VALUE] = -1;
pItem->optionValue[item_t::ITEM_T_CHARGE_VALUE] = count;
}
Fx_CHARACTER_t * CTools::FindCharacter(const int EntityType,const int IdxOnServer)
{
Fx_CHARACTER_t *character = &g_charManager->m_Characters[0];
int numCharacter =g_charManager->m_iNumCharacters;
for (int i=0; i < numCharacter; i++, character++)
{
if (EntityType == character->entityType && IdxOnServer == character->idxOnServer)
{
return character;
}
}
return NULL;
}
bool CTools::IfMyCharacter(const Fx_CHARACTER_t *character)
{
if( character->idxOnServer == g_cgv.myPCIdxOnServer &&
character->entityType == ENTITY_PC )
return true;
return false;
}
bool CTools::IfSkillCasting_NotItemUse()
{
if(g_cgv.myCharacterInfo->skillCastingtime > 0)
{
if(g_cgv.saveInventoryIdx >= 0 && g_cgv.saveInventoryIdx < MAX_INVENTORY_SIZE)
{
int itemIdx = g_cgv.myCharacterInfo->inventory[g_cgv.saveInventoryIdx];
if(itemIdx >= 0 && itemIdx < MAX_NUMBER_OF_OWNITEM)
{
int itemTableIdx;
item_t *item=NULL;
item = &g_cgv.myCharacterInfo->item[itemIdx];
itemTableIdx = item->itemTableIdx;
if(itemTableIdx >=0 && itemTableIdx < MAX_NUMBER_OF_ITEM_TABLE)
{
char szTemp[256];
sprintf( szTemp, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 200 ),g_itemTable[itemTableIdx].name );
g_ifMng->AddSysMessage( szTemp );
}
}
}
return true;
}
return false;
}
bool CTools::DeleteInventoryItem(int invenPos)
{
item_t *item = NULL;
if ( 0 > invenPos || MAX_INVENTORY_SIZE <= invenPos) return false;
int itemIdx = g_cgv.myCharacterInfo->inventory[invenPos];
if ( 0 > itemIdx || MAX_NUMBER_OF_OWNITEM <= itemIdx ) return false;
item = &g_cgv.myCharacterInfo->item[itemIdx];
if ( item == NULL) return false;
if( item->durability > 0 )
{
item->durability --;
}
else
{
GTH_DeleteMyItem( &g_cgv.myCharacterInfo->item[itemIdx] );
g_cgv.myCharacterInfo->inventory[invenPos] = -1;
}
return true;
}
void CTools::CcToGs(int sysType,int mainType,int subType)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, sysType);
MSG_WriteShort(&netMessage, mainType);
MSG_WriteShort(&netMessage, subType);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CTools::CcToGs(int sysType,int mainType,int subType,int val)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, sysType);
MSG_WriteShort(&netMessage, mainType);
MSG_WriteShort(&netMessage, subType);
MSG_WriteLong(&netMessage, val);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CTools::CcToGs(int sysType,int mainType,int subType,char *TargetPlayerName)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, sysType);
MSG_WriteShort(&netMessage, mainType);
MSG_WriteShort(&netMessage, subType);
MSG_WriteString(&netMessage,TargetPlayerName);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CTools::CcToGs(int sysType,int mainType,int subType,int val, char *TargetPlayerName)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, sysType);
MSG_WriteShort(&netMessage, mainType);
MSG_WriteShort(&netMessage, subType);
MSG_WriteLong(&netMessage, val);
MSG_WriteString(&netMessage,TargetPlayerName);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CTools::CcToGs(int sysType,int mainType,int subType, char *RequestPlayerName, char *TargetPlayerName)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, sysType);
MSG_WriteShort(&netMessage, mainType);
MSG_WriteShort(&netMessage, subType);
MSG_WriteString(&netMessage,RequestPlayerName);
MSG_WriteString(&netMessage,TargetPlayerName);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CTools::CcToGs(int sysType,int mainType,int subType,int worldIdx,vec3_t position, char *TargetPlayerName)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, sysType);
MSG_WriteShort(&netMessage, mainType);
MSG_WriteShort(&netMessage, subType);
MSG_WriteByte(&netMessage, worldIdx);
MSG_WritePosition(&netMessage, position);
MSG_WriteString(&netMessage,TargetPlayerName);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CTools::CcToGs(int sysType,int mainType,int subType, int worldIdx, vec3_t position, char *RequestPlayerName, char *TargetPlayerName)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, sysType);
MSG_WriteShort(&netMessage, mainType);
MSG_WriteShort(&netMessage, subType);
MSG_WriteByte(&netMessage, worldIdx);
MSG_WritePosition(&netMessage, position);
MSG_WriteString(&netMessage,RequestPlayerName);
MSG_WriteString(&netMessage,TargetPlayerName);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
} | C++ |
#if !defined(AFX_CHECKSUM_H__25AE8BA5_981D_4BF5_B9FA_CB7B5259ECE3__INCLUDED_)
#define AFX_CHECKSUM_H__25AE8BA5_981D_4BF5_B9FA_CB7B5259ECE3__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include <windows.h>
class checksum {
public:
checksum() { clear(); }
void clear() { sum = 0; r = 55665; c1 = 52845; c2 = 22719;}
void add(DWORD w);
void add(BOOL w) { add((DWORD)w); }
void add(UINT w) { add((DWORD)w); }
void add(WORD w);
void add(LPBYTE b, UINT length);
void add(BYTE b);
DWORD get() { return sum; }
protected:
WORD r;
WORD c1;
WORD c2;
DWORD sum;
};
#endif
| C++ |
enum
{
INPUT_KEY_NONE = 0,
INPUT_KEY_DOWN,
INPUT_KEY_UP,
INPUT_KEY_KEEP,
INPUT_KEY_EVENT,
};
enum
{
INPUT_MOUSE_NONE = 0,
INPUT_MOUSE_DOWN,
INPUT_MOUSE_UP,
INPUT_MOUSE_DBCLK,
INPUT_MOUSE_KEEP,
};
enum
{
INPUT_MOUSE_NORMAL_MODE = 0,
INPUT_MOUSE_SCROLL_MODE,
INPUT_MOUSE_WHEEL_MODE,
INPUT_MOUSE_INTERFACE_MODE
};
enum
{
CURSOR_POINTER = 0,
CURSOR_ATTACK,
CURSOR_CHAT,
CURSOR_REPAIR,
CURSOR_NULL,
};
enum
{
MOUSE_CURSOR_TYPE = 0,
ITEM_CURSOR_TYPE,
SKILL_CURSOR_TYPE,
ACTION_CURSOR_TYPE,
};
#define NUM_MOUSE_BUTTON 5
class CInputMng
{
public :
CInputMng();
~CInputMng();
LPDIRECTINPUT8 m_pDI;
LPDIRECTINPUTDEVICE8 m_pKeyboard;
LPDIRECTINPUTDEVICE8 m_pMouse;
BYTE m_diks[256];
BYTE m_oldDiks[256];
HWND m_hwnd;
POINT m_mousePos;
POINT m_mouseCurrPos;
POINT m_mousePrevPos;
POINT m_mouseMidPos;
DIMOUSESTATE2 m_dims;
DIMOUSESTATE2 m_oldDims;
int m_mouseDBClk[NUM_MOUSE_BUTTON];
int m_isWheeled;
int m_wheelDelta;
int m_mouseMode;
int m_mouseShowFlag;
int m_mouseCursorType;
int m_mouseCursorID;
int m_mouseCursorData;
bool m_mouseEnable;
bool m_keyEnable;
void MouseEnable( int state = true ) { m_mouseEnable = state; }
void KeyEnable( int state = true ) { m_keyEnable = state; }
void FreeDevice();
int CreateDevice();
void FreeKeyDevice();
int CreateKeyDevice( int dwCoopFlags = DISCL_EXCLUSIVE | DISCL_FOREGROUND | DISCL_NOWINKEY );
int ReadKeyImmediateData();
int UpdateKeyData();
int KeyState( DWORD element, int type );
void SetKeyState( DWORD element, int newType = 0, int oldType = 0 );
int KeyNone( DWORD element );
int KeyDown( DWORD element );
int KeyUp( DWORD element );
int KeyKeep( DWORD element );
int KeyEvent( DWORD element );
void FreeMouseDevice();
int CreateMouseDevice( int dwCoopFlags = DISCL_EXCLUSIVE | DISCL_FOREGROUND | DISCL_NOWINKEY );
int ReadMouseImmediateData();
int UpdateMouseData();
void SetHWND( HWND hwnd ) { m_hwnd = hwnd; }
bool Handle_messages( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp );
void ChangeCursor( int cursorID = 0, int type = MOUSE_CURSOR_TYPE, int data = -1 );
int GetCursorState( int cursorID, int type = MOUSE_CURSOR_TYPE );
int GetCursorData() { return( m_mouseCursorData ); }
void Show();
void Hide();
void Resize( int width , int height );
int GetPosX() { return m_mouseCurrPos.x; }
int GetPosY() { return m_mouseCurrPos.y; }
int GetDeltaX() { return m_mouseCurrPos.x - m_mousePrevPos.x; }
int GetDeltaY() { return m_mouseCurrPos.y - m_mousePrevPos.y; }
int GetMouseMode() { return m_mouseMode; }
void SetMouseMode( int mode ) { m_mouseMode = mode; }
void GetCursorPos( POINT& p );
void GetDelta( POINT& p );
void Center();
int GetWheelDelta();
int GetButtonState( int btnType, int type );
int GetLBDown();
int GetRBDown();
int GetMBDown();
int GetLBKeep();
int GetRBKeep();
int GetMBKeep();
int GetLBUp();
int GetRBUp();
int GetMBUp();
int GetLBDBClk();
int GetRBDBClk();
int GetMBDBClk();
int GetLBNone();
int GetRBNone();
int GetMBNone();
void InvalidateDeviceObject();
};
| C++ |
#include "netlib.h"
#include "queue.h"
CSendingQueue::CSendingQueue()
{
m_first = 0;
m_last = -1;
m_count = 0;
m_size = SENDING_QUEUE_SIZE;
m_overflow = false;
m_maxCount = 0;
memset( m_queue , 0 , sizeof(i3packetqueue_t) * SENDING_QUEUE_SIZE );
}
CSendingQueue::~CSendingQueue()
{
}
int CSendingQueue::Push (int socket, byte *buf, int len, struct sockaddr_in *addr)
{
if (m_count >= m_size)
{
m_overflow = true;
return 0;
}
if (m_last < m_size - 1)
m_last ++;
else
m_last = 0;
m_queue[m_last].socket = socket;
m_queue[m_last].len = len;
memcpy( &m_queue[m_last].packet, buf, len );
memcpy( &m_queue[m_last].addr, addr, sizeof(sockaddr_in) );
m_count ++;
if (m_count > m_maxCount)
m_maxCount = m_count;
return 1;
}
int CSendingQueue::Pop (int *socket, byte *buf, int *len, struct sockaddr_in *addr)
{
if (m_count <= 0)
{
return 0;
}
*socket = m_queue[m_first].socket;
*len = m_queue[m_first].len;
memcpy( buf, &m_queue[m_first].packet, m_queue[m_first].len );
memcpy( addr, &m_queue[m_first].addr, sizeof(sockaddr_in) );
if (m_first < m_size - 1)
m_first ++;
else
m_first = 0;
m_count --;
return 1;
}
void CSendingQueue::Clear()
{
CSendingQueue();
}
CReceivingQueue::CReceivingQueue()
{
m_first = 0;
m_last = -1;
m_count = 0;
m_size = RECEIVING_QUEUE_SIZE;
m_overflow = false;
m_maxCount = 0;
memset( m_queue , 0 , sizeof(i3packetqueue_t) * RECEIVING_QUEUE_SIZE );
}
CReceivingQueue::~CReceivingQueue()
{
}
int CReceivingQueue::Push (int socket, byte *buf, int len, struct sockaddr_in *addr)
{
if (m_count >= m_size)
{
m_overflow = true;
return 0;
}
if (m_last < m_size - 1)
m_last ++;
else
m_last = 0;
m_queue[m_last].socket = socket;
m_queue[m_last].len = len;
memcpy( &m_queue[m_last].packet, buf, len );
memcpy( &m_queue[m_last].addr, addr, sizeof(sockaddr_in) );
m_count ++;
if (m_count > m_maxCount)
m_maxCount = m_count;
return 1;
}
int CReceivingQueue::Pop (int *socket, byte *buf, int *len, struct sockaddr_in *addr)
{
if (m_count <= 0)
{
return 0;
}
*socket = m_queue[m_first].socket;
*len = m_queue[m_first].len;
memcpy( buf, &m_queue[m_first].packet, m_queue[m_first].len );
memcpy( addr, &m_queue[m_first].addr, sizeof(sockaddr_in) );
if (m_first < m_size - 1)
m_first ++;
else
m_first = 0;
m_count --;
return 1;
}
void CReceivingQueue::Clear()
{
CReceivingQueue();
}
| C++ |
#include "netlib.h"
#include "queue.h"
#include <time.h>
extern i3sizebuf_t netMessage;
extern i3sizebuf_t recvMessage;
extern int msgReadCount;
extern int msgBadRead;
extern int readSizePerSecond;
extern CRITICAL_SECTION spCrit;
void MSG_BeginWriting(i3sizebuf_t *sb)
{
EnterCriticalSection( &spCrit );
}
void MSG_EndWriting(i3sizebuf_t *sb)
{
LeaveCriticalSection( &spCrit );
}
void MSG_Clear( i3sizebuf_t *sb )
{
SZ_Clear( sb );
}
void MSG_WriteChar (i3sizebuf_t *sb, int c)
{
byte *buf;
buf = SZ_GetSpace (sb, 1);
buf[0] = c;
}
void MSG_WriteByte (i3sizebuf_t *sb, int c)
{
byte *buf;
buf = SZ_GetSpace (sb, 1);
buf[0] = c;
}
void MSG_WriteShort (i3sizebuf_t *sb, int c)
{
byte *buf;
buf = SZ_GetSpace (sb, 2);
buf[0] = c&0xff;
buf[1] = c>>8;
}
void MSG_WriteLong (i3sizebuf_t *sb, int c)
{
byte *buf;
buf = SZ_GetSpace (sb, 4);
buf[0] = c&0xff;
buf[1] = (c>>8)&0xff;
buf[2] = (c>>16)&0xff;
buf[3] = c>>24;
}
void MSG_Write64Int (i3sizebuf_t *sb, __int64 in_n64Value)
{
byte *pBuffer;
pBuffer = SZ_GetSpace (sb, 8);
pBuffer[0] = (in_n64Value>>0) & 0xff;
pBuffer[1] = (in_n64Value>>8) & 0xff;
pBuffer[2] = (in_n64Value>>16) & 0xff;
pBuffer[3] = (in_n64Value>>24) & 0xff;
pBuffer[4] = (in_n64Value>>32) & 0xff;
pBuffer[5] = (in_n64Value>>40) & 0xff;
pBuffer[6] = (in_n64Value>>48) & 0xff;
pBuffer[7] = (in_n64Value>>56) & 0xff;
}
void MSG_WriteString (i3sizebuf_t *sb, char *s)
{
if (!s)
SZ_Write (sb, "", 1);
else
SZ_Write (sb, s, strlen(s)+1);
}
void MSG_WriteFloat (i3sizebuf_t *sb, float f)
{
union
{
float f;
int l;
} dat;
dat.f = f;
SZ_Write (sb, &dat.l, 4);
}
void MSG_WriteAngle (i3sizebuf_t *sb, float f)
{
MSG_WriteByte (sb, ((int)f*256/360) & 255);
}
void MSG_WriteVector(i3sizebuf_t *sb, vec3_t v)
{
MSG_WriteFloat(sb, v[0]);
MSG_WriteFloat(sb, v[1]);
MSG_WriteFloat(sb, v[2]);
}
void MSG_ReadVector(vec3_t v)
{
readSizePerSecond += 16;
v[0] = MSG_ReadFloat();
v[1] = MSG_ReadFloat();
v[2] = MSG_ReadFloat();
}
void MSG_BeginReading (void)
{
msgReadCount = 0;
msgBadRead = false;
}
int MSG_ReadChar (void)
{
readSizePerSecond += 1;
int c;
if (msgReadCount+1 > recvMessage.cursize)
{
msgBadRead = true;
return -1;
}
c = (signed char)recvMessage.data[msgReadCount];
msgReadCount++;
return c;
}
int MSG_ReadByte (void)
{
readSizePerSecond += 1;
int c;
if (msgReadCount+1 > recvMessage.cursize)
{
msgBadRead = true;
return -1;
}
c = (unsigned char)recvMessage.data[msgReadCount];
msgReadCount++;
return c;
}
int MSG_ReadShort (void)
{
readSizePerSecond += 2;
int c;
if (msgReadCount+2 > recvMessage.cursize)
{
msgBadRead = true;
return -1;
}
c = (short)(recvMessage.data[msgReadCount]
+ (recvMessage.data[msgReadCount+1]<<8));
msgReadCount += 2;
return c;
}
int MSG_ReadLong (void)
{
readSizePerSecond += 4;
int c;
if (msgReadCount+4 > recvMessage.cursize)
{
msgBadRead = true;
return -1;
}
c = recvMessage.data[msgReadCount]
+ (recvMessage.data[msgReadCount+1]<<8)
+ (recvMessage.data[msgReadCount+2]<<16)
+ (recvMessage.data[msgReadCount+3]<<24);
msgReadCount += 4;
return c;
}
__int64 MSG_Read64Int (void)
{
readSizePerSecond += 8;
__int64 i64Value=0x00;
if (msgReadCount+8 > recvMessage.cursize)
{
msgBadRead = true;
return -1;
}
i64Value =
((__int64)(recvMessage.data[msgReadCount+0])<<0)
+ ((__int64)(recvMessage.data[msgReadCount+1])<<8)
+ ((__int64)(recvMessage.data[msgReadCount+2])<<16)
+ ((__int64)(recvMessage.data[msgReadCount+3])<<24)
+ ((__int64)(recvMessage.data[msgReadCount+4])<<32)
+ ((__int64)(recvMessage.data[msgReadCount+5])<<40)
+ ((__int64)(recvMessage.data[msgReadCount+6])<<48)
+ ((__int64)(recvMessage.data[msgReadCount+7])<<56);
msgReadCount += 8;
return i64Value;
}
char *MSG_ReadString (void)
{
static char string[2048];
int l,c;
l = 0;
do
{
c = MSG_ReadChar ();
if (c == -1 || c == 0)
break;
string[l] = c;
l++;
} while (l < sizeof(string)-1);
string[l] = 0;
readSizePerSecond += l;
return string;
}
float MSG_ReadFloat (void)
{
readSizePerSecond += 4;
union
{
byte b[4];
float f;
int l;
} dat;
dat.b[0] = recvMessage.data[msgReadCount];
dat.b[1] = recvMessage.data[msgReadCount+1];
dat.b[2] = recvMessage.data[msgReadCount+2];
dat.b[3] = recvMessage.data[msgReadCount+3];
msgReadCount += 4;
return dat.f;
}
float MSG_ReadAngle (void)
{
readSizePerSecond += 1;
return float( MSG_ReadByte() * (360.0/256) );
}
void SZ_Clear (i3sizebuf_t *buf)
{
buf->cursize = 0;
buf->overwriting = 0;
}
unsigned char *SZ_GetSpace (i3sizebuf_t *buf, int length)
{
unsigned char *data;
if (buf->cursize + length > buf->maxsize)
{
buf->overflowed = true;
SZ_Clear (buf);
}
data = buf->data + buf->cursize;
buf->cursize += length;
return data;
}
void SZ_Write (i3sizebuf_t *buf, void *data, int length)
{
memcpy (SZ_GetSpace(buf,length),data,length);
}
void SZ_Alloc (i3sizebuf_t *buf, int startsize)
{
buf->maxsize = startsize;
buf->cursize = 0;
buf->overwriting = 0;
}
void SZ_Free (i3sizebuf_t *buf)
{
buf->cursize = 0;
buf->overwriting = 0;
}
void SZ_Load (i3sizebuf_t *buf, void *data)
{
memcpy (data, buf->data, buf->cursize);
}
| C++ |
#ifndef _NETLIB_H_
#define _NETLIB_H_
#pragma warning( disable : 4786 )
#pragma warning( disable : 4251 )
#define NETLIB_VERSION "03.10.03"
#include <stdio.h>
#include <math.h>
#include <ctime>
#include <map>
#include <stack>
#include <winsock.h>
#define _COMPILE_FOR_CLIENT
#ifdef _COMPILE_FOR_SERVER
#define _USE_SENDING_THREAD
#define _USE_RECEIVING_THREAD
#endif
#define NET_MAXMESSAGE 8192
#define MAX_DATAGRAM 1024
#define NET_HEADERSIZE (sizeof(unsigned int) + sizeof(unsigned int) + sizeof(unsigned int) +sizeof(unsigned short))
#define NET_DATAGRAMSIZE (MAX_DATAGRAM + NET_HEADERSIZE)
#define NET_MAXWAITINGMESSAGE 8
#define NETFLAG_LENGTH_MASK 0x0fff
#define NETFLAG_SOM 1 << 0
#define NETFLAG_RELIABLE 1 << 1
#define NETFLAG_ACK 1 << 2
#define NETFLAG_EOM 1 << 3
#define NETFLAG_ENCRYPT 1 << 0
#define NETFLAG_ENCRYPT_CHECKSUM 0X7FFFFFFF
#define NET_RESENDTIME 800
#define NET_MAXIMUM_PACKETMAP_SIZE 100
#define NET_SENDTIME_UNRELIABLE 0
#define MAXHOSTNAMELEN 256
#define MAX_CHANNELS 20
typedef float vec3_t[3];
typedef struct
{
int allowoverflow;
int overflowed;
byte data[NET_MAXMESSAGE];
int maxsize;
int cursize;
int overwriting;
} i3sizebuf_t;
#pragma pack ( push , 1 )
typedef struct
{
unsigned int sequence;
unsigned int encrypt :1 ;
unsigned int checksum : 31;
unsigned int lastSendTime;
unsigned short length;
byte data[MAX_DATAGRAM];
} i3packet_t;
#pragma pack ( pop )
typedef std::map<UINT, i3packet_t*> PacketMap;
typedef PacketMap::iterator PacketMapItor;
typedef PacketMap::value_type PacketMapPair;
enum
{
SocketType_Reliable,
SocketType_Unreliable
};
enum
{
PacketBlock_None,
PacketBlock_Wait,
};
typedef struct i3socket_s
{
i3socket_s()
{
sendPacketMap = NULL;
recvPacketMap = NULL;
socket = INVALID_SOCKET;
socketType = SocketType_Reliable;
}
int socket;
int socketType;
unsigned int connecttime;
unsigned int lastReceiveTime;
unsigned int lastSendTime;
unsigned int latencyTime;
int disconnected;
int canSend;
int sendNext;
unsigned int resendSequence;
unsigned int ackSequence;
unsigned int sendSequence;
unsigned int unreliableSendSequence;
int sendMessageLength;
byte sendMessage [NET_MAXMESSAGE];
unsigned int receiveSequence;
unsigned int unreliableReceiveSequence;
int receiveMessageLength;
byte receiveMessage [NET_MAXMESSAGE];
int packetBlockSequence;
struct sockaddr_in addr;
PacketMap *sendPacketMap;
PacketMap *recvPacketMap;
} i3socket_t;
enum
{
PacketAnalysis_None = 0,
PacketAnalysis_Skip,
PacketAnalysis_Ack,
PacketAnalysis_Start,
};
void SZ_Write (i3sizebuf_t *buf, void *data, int length);
void SZ_Clear (i3sizebuf_t *buf);
void SZ_Alloc (i3sizebuf_t *buf, int startsize);
unsigned char *SZ_GetSpace (i3sizebuf_t *buf, int length);
void SZ_Load (i3sizebuf_t *buf, void *data);
void MSG_BeginWriting(i3sizebuf_t *sb);
void MSG_EndWriting(i3sizebuf_t *sb);
void MSG_Clear( i3sizebuf_t *sb );
void MSG_WriteChar (i3sizebuf_t *sb, int c);
void MSG_WriteByte (i3sizebuf_t *sb, int c);
void MSG_WriteShort (i3sizebuf_t *sb, int c);
void MSG_WriteLong (i3sizebuf_t *sb, int c);
void MSG_Write64Int (i3sizebuf_t *sb, __int64 c);
void MSG_WriteFloat (i3sizebuf_t *sb, float f);
void MSG_WriteString (i3sizebuf_t *sb, char *s);
void MSG_WriteAngle (i3sizebuf_t *sb, float f);
void MSG_WriteVector(i3sizebuf_t *sb, vec3_t v);
void MSG_BeginReading (void);
int MSG_ReadChar (void);
int MSG_ReadByte (void);
int MSG_ReadShort (void);
int MSG_ReadLong (void);
__int64 MSG_Read64Int (void);
float MSG_ReadFloat (void);
char *MSG_ReadString (void);
float MSG_ReadAngle (void);
void MSG_ReadVector(vec3_t v);
int NET_AddrCompare (struct sockaddr *addr1, struct sockaddr *addr2);
char *NET_AddrToString (struct sockaddr *addr);
int NET_StringToAddr (char *string, struct sockaddr *addr);
char *NET_GetLocalAddress();
char *NET_GetHostName();
char *NET_AddrToIPString (struct sockaddr *addr);
int NET_SendPacket (i3socket_t *sock, i3sizebuf_t *data, BOOL encrypt = FALSE);
int NET_SendPacket_Unreliable(i3socket_t *sock, i3sizebuf_t *data, BOOL encrypt = FALSE);
int NET_ReadPacket(int *socket, byte *buf, struct sockaddr_in *addr);
int NET_ControlPacket(i3socket_t *sock, i3packet_t *packet);
int NET_ControlRecvBank( i3socket_t *sock );
int NET_ControlSendBank( i3socket_t *sock );
int NET_CheckSockProblem( i3socket_t *sock, int checkTime = -1 );
int NET_PreviewMessage(i3packet_t *p);
int NET_Write (int socket, byte *buf, int len, struct sockaddr_in *addr);
int NET_Read (int socket, byte *buf, int len, struct sockaddr_in *addr);
int NET_ReadFromReceivingQueue (int *socket, byte *buf, struct sockaddr_in *addr);
int NET_WriteToSendingQueue (int socket, byte *buf, int len, struct sockaddr_in *addr);
void NET_InitNetTime();
unsigned int NET_GetNetTime();
int NET_OpenNetwork();
void NET_InitPacketMap( i3socket_t *sock );
int NET_InitSocket(i3socket_t *sock, struct sockaddr_in *addr, int socket, int socketType );
int NET_OpenSocketForServer(i3socket_t *sock, char *serverIP, int port, int socketType = SocketType_Reliable );
int NET_OpenSocketForClient(i3socket_t *sock, char *serverIP, int port, int socketType = SocketType_Reliable );
void NET_CloseSocket(i3socket_t *sock);
void NET_ClearSocket(i3socket_t *sock);
void NET_CloseNetwork();
int NET_CreateSendingThread();
int NET_CreateReceivingThread();
void NET_DestroySendingThread();
void NET_DestroyReceivingThread();
DWORD WINAPI NET_SendingThread(LPVOID param);
DWORD WINAPI NET_ReceivingThread(LPVOID param);
char *NET_ErrorString ();
int NET_AddListenChannel( int socket );
int NET_DeleteListenChannel( int socket );
#define NET_SendMessage NET_SendPacket
#define NET_SendUnreliableMessage NET_SendPacket_Unreliable
void Crypt(TCHAR *inp, DWORD inplen, TCHAR* key = "", DWORD keylen = 0);
#endif
| C++ |
#include "netlib.h"
#include "queue.h"
#include <time.h>
extern i3sizebuf_t netMessage;
extern i3sizebuf_t recvMessage;
extern i3packet_t packetBuffer;
extern int totalPacketsSend;
extern int totalPacketsReceived;
extern int packetsSent;
extern int packetsReceived;
extern int packetsReSent;
extern int packetsDropCount;
extern int packetsDupCount;
extern int packetsAckSent;
extern int packetsAckReceived;
extern int un_packetsSent;
extern int un_packetsReceived;
extern int un_packetsDropCount;
extern unsigned int g_netTime;
extern unsigned int prevTime;
extern unsigned int curTime;
extern int channel[ MAX_CHANNELS ];
extern int channelNumber;
extern HANDLE hThread;
extern DWORD SendingThreadID, ReceivingThreadID;
extern int runSendingThread, runReceivingThread;
extern CSendingQueue *sendingQueue;
extern CReceivingQueue *receivingQueue;
extern HANDLE hSQMutex, hRQMutex;
extern FILE *packetErrorLog;
extern int lastRecvSequence;
extern int myRecvSequence;
extern CRITICAL_SECTION spCrit;
using namespace std;
#include <string>
#include <vector>
#include "../CheckSum.h"
int sendFirstWrite = true;
int recvFirstWrite = true;
int g_lastWriteSequence = -1;
void WriteCompletePacket( int idx, int type )
{
return;
int *firstwrite;
char filename[256];
char msg[128];
if( type == 0 )
{
strcpy( filename, "send.txt" );
firstwrite = &sendFirstWrite;
strcpy( msg, "-" );
}
else if( type == 1 )
{
strcpy( filename, "recv.txt" );
firstwrite = &recvFirstWrite;
strcpy( msg, "-" );
if( g_lastWriteSequence < 0 ) g_lastWriteSequence = idx;
else if( g_lastWriteSequence != idx )
{
int checkSequence = 1;
}
else g_lastWriteSequence = idx;
}
else if( type == 2 )
{
strcpy( filename, "recv.txt" );
firstwrite = &recvFirstWrite;
sprintf( msg, "dup : %d<%d", myRecvSequence, lastRecvSequence );
}
else if( type == 3 )
{
strcpy( filename, "recv.txt" );
firstwrite = &recvFirstWrite;
sprintf( msg, "drop : %d>%d", myRecvSequence, lastRecvSequence );
}
FILE *fp;
if( (*firstwrite) )
{
fp = fopen( filename, "wt" );
(*firstwrite) = false;
}
else
{
fp = fopen( filename, "at" );
}
fprintf( fp, "%s[%d]packet complete\n", msg, idx );
fclose( fp );
}
void NET_WriteErrorLog( char* str, struct sockaddr_in *addr )
{
return;
char cTime[32];
time_t logtime;
time( &logtime );
strcpy( cTime, ctime( &logtime ) );
cTime[24] = '\0';
#ifdef _COMPILE_FOR_SERVER
packetErrorLog = fopen( "net_error.txt", "at" );
#else
packetErrorLog = fopen( "../net_error.txt", "at" );
#endif
fprintf( packetErrorLog, "%s : %s(%s)\n", cTime, str, inet_ntoa( addr->sin_addr ) );
fclose( packetErrorLog );
}
int NET_AddrCompare (struct sockaddr *addr1, struct sockaddr *addr2)
{
if (addr1->sa_family != addr2->sa_family)
return -1;
if (((struct sockaddr_in *)addr1)->sin_addr.s_addr != ((struct sockaddr_in *)addr2)->sin_addr.s_addr)
return -1;
if (((struct sockaddr_in *)addr1)->sin_port != ((struct sockaddr_in *)addr2)->sin_port)
return 1;
return 0;
}
char *NET_AddrToString (struct sockaddr *addr)
{
static char buffer[22];
int haddr;
haddr = ntohl(((struct sockaddr_in *)addr)->sin_addr.s_addr);
sprintf(buffer, "%d.%d.%d.%d:%d", (haddr >> 24) & 0xff, (haddr >> 16) & 0xff, (haddr >> 8) & 0xff, haddr & 0xff, ntohs(((struct sockaddr_in *)addr)->sin_port));
return buffer;
}
int NET_StringToAddr (char *string, struct sockaddr *addr)
{
int ha1, ha2, ha3, ha4, hp;
int ipaddr;
sscanf(string, "%d.%d.%d.%d:%d", &ha1, &ha2, &ha3, &ha4, &hp);
ipaddr = (ha1 << 24) | (ha2 << 16) | (ha3 << 8) | ha4;
addr->sa_family = AF_INET;
((struct sockaddr_in *)addr)->sin_addr.s_addr = htonl(ipaddr);
((struct sockaddr_in *)addr)->sin_port = htons((unsigned short)hp);
return 0;
}
char *NET_GetLocalAddress()
{
struct hostent *hostEntry;
int haddr;
static char buffer[16];
char hostName[MAXHOSTNAMELEN];
if ( gethostname(hostName, MAXHOSTNAMELEN) == SOCKET_ERROR ) return NULL;
hostEntry = gethostbyname( hostName );
if (hostEntry == NULL) return NULL;
haddr = ntohl( *(int *)hostEntry->h_addr );
sprintf(buffer, "%d.%d.%d.%d", (haddr >> 24) & 0xff, (haddr >> 16) & 0xff, (haddr >> 8) & 0xff, haddr & 0xff);
return buffer;
}
char *NET_AddrToIPString (struct sockaddr *addr)
{
static char buffer[16];
int haddr;
haddr = ntohl(((struct sockaddr_in *)addr)->sin_addr.s_addr);
sprintf(buffer, "%d.%d.%d.%d", (haddr >> 24) & 0xff, (haddr >> 16) & 0xff, (haddr >> 8) & 0xff, haddr & 0xff);
return buffer;
}
char *NET_GetHostName()
{
static char hostNameString[MAXHOSTNAMELEN];
if ( gethostname(hostNameString, MAXHOSTNAMELEN) == SOCKET_ERROR ) return NULL;
return hostNameString;
}
void NET_ClearBank( PacketMap *pm )
{
for( PacketMapItor itor = pm->begin(); itor != pm->end(); ++itor )
{
if( ((*itor).second) == NULL ) continue;
delete ((*itor).second);
}
pm->clear();
}
int NET_InsertPacketBank( PacketMap *pm, i3packet_t *packet )
{
PacketMapItor itor = pm->find( packet->sequence );
i3packet_t *pk;
if( itor != pm->end() ) return false;
pk = new i3packet_t;
memcpy( pk, packet, sizeof( i3packet_t ) );
pm->insert( PacketMapPair( packet->sequence, pk ) );
return true;
}
int NET_DeletePacketBank( PacketMap *pm, UINT sequence )
{
PacketMapItor itor = pm->find( sequence );
if( itor == pm->end() ) return false;
delete (*itor).second;
pm->erase( itor );
return true;
}
int NET_SendPacket (i3socket_t *sock, i3sizebuf_t *data, BOOL bEncrypt)
{
unsigned int packetLen;
unsigned int dataLen;
byte som;
byte eom;
unsigned int encrypt = 0;
if (data->cursize == 0)
{
packetsDropCount++;
return 0;
}
if (data->cursize > NET_MAXMESSAGE)
{
packetsDropCount++;
return 0;
}
memcpy(sock->sendMessage, data->data, data->cursize);
sock->sendMessageLength = data->cursize;
som = 0xff;
while( 1 )
{
if (sock->sendMessageLength <= MAX_DATAGRAM)
{
dataLen = sock->sendMessageLength;
eom = NETFLAG_EOM;
som = 0;
}
else
{
dataLen = MAX_DATAGRAM;
eom = 0;
if( som == 0xff ) som = NETFLAG_SOM;
else som = 0;
}
packetLen = NET_HEADERSIZE + dataLen;
if( sock->socketType == SocketType_Reliable)
packetBuffer.length = ((NETFLAG_RELIABLE | eom) << 12) | packetLen;
else
packetBuffer.length = ((NETFLAG_RELIABLE | eom | som) << 12) | packetLen;
packetBuffer.sequence = sock->sendSequence++;
packetBuffer.lastSendTime = g_netTime;
packetBuffer.encrypt = bEncrypt;
memcpy( packetBuffer.data, sock->sendMessage, dataLen );
if (bEncrypt == TRUE)
{
Crypt((TCHAR*)packetBuffer.data, dataLen);
checksum packetsum;
packetsum.clear();
packetsum.add((BYTE*)packetBuffer.data, dataLen);
packetBuffer.checksum = packetsum.get();
}
if( sock->sendPacketMap != NULL )
{
if( sock->socketType == SocketType_Reliable ) NET_InsertPacketBank( sock->sendPacketMap, &packetBuffer );
}
#ifndef _USE_SENDING_THREAD
if (NET_Write(sock->socket, (byte *)&packetBuffer, packetLen, &sock->addr) == -1)
#else
if (NET_WriteToSendingQueue(sock->socket, (byte *)&packetBuffer, packetLen, &sock->addr) == -1)
#endif
return -1;
sock->lastSendTime = NET_GetNetTime();
totalPacketsSend ++;
packetsSent ++;
if( eom != 0 ) break;
sock->sendMessageLength -= MAX_DATAGRAM;
memcpy( sock->sendMessage, sock->sendMessage+MAX_DATAGRAM, sock->sendMessageLength );
}
return 1;
}
int NET_SendPacket_Unreliable(i3socket_t *sock, i3sizebuf_t *data, BOOL bEncrypt)
{
if( sock->socketType == SocketType_Unreliable )
{
return( NET_SendPacket( sock, data ) );
}
unsigned int packetLen;
unsigned int dataLen;
byte eom;
if (data->cursize == 0)
{
un_packetsDropCount++;
return 0;
}
if (data->cursize > MAX_DATAGRAM)
{
un_packetsDropCount++;
return 0;
}
memcpy(sock->sendMessage, data->data, data->cursize);
sock->sendMessageLength = data->cursize;
dataLen = sock->sendMessageLength;
eom = NETFLAG_EOM;
packetLen = NET_HEADERSIZE + dataLen;
packetBuffer.length = ((NETFLAG_RELIABLE | eom) << 12) | packetLen;
packetBuffer.sequence = sock->unreliableSendSequence ++;
packetBuffer.lastSendTime = NET_SENDTIME_UNRELIABLE;
unsigned int CheckSum = 0;
packetBuffer.encrypt = bEncrypt;
memcpy( packetBuffer.data, sock->sendMessage, dataLen );
if (bEncrypt == TRUE)
{
Crypt((TCHAR*)packetBuffer.data, dataLen);
checksum packetsum;
packetsum.clear();
packetsum.add((BYTE*)packetBuffer.data, dataLen);
packetBuffer.checksum = packetsum.get();
}
#ifndef _USE_SENDING_THREAD
if (NET_Write(sock->socket, (byte *)&packetBuffer, packetLen, &sock->addr) == -1)
#else
if (NET_WriteToSendingQueue(sock->socket, (byte *)&packetBuffer, packetLen, &sock->addr) == -1)
#endif
return -1;
sock->lastSendTime = NET_GetNetTime();
totalPacketsSend ++;
un_packetsSent ++;
return 1;
}
int NET_ControlSendBank( i3socket_t *sock )
{
int packetLen;
if( sock->sendPacketMap == NULL ) return 0;
if( sock->sendPacketMap->empty() ) return 0;
int sendSize = sock->sendPacketMap->size();
i3packet_t *packet;
for( PacketMapItor itor = sock->sendPacketMap->begin(); itor != sock->sendPacketMap->end(); ++itor )
{
if( g_netTime - ((*itor).second)->lastSendTime < NET_RESENDTIME ) continue;
packet = (*itor).second;
packet->lastSendTime = g_netTime;
packetLen = ( packet->length & NETFLAG_LENGTH_MASK );
packetsReSent ++;
totalPacketsSend ++;
#ifndef _USE_SENDING_THREAD
if (NET_Write(sock->socket, (byte *)packet, packetLen, &sock->addr) == -1)
#else
if (NET_WriteToSendingQueue(sock->socket, (byte *)packet, packetLen, &sock->addr) == -1)
#endif
return -1;
}
return 1;
}
int NET_ControlRecvBank( i3socket_t *sock )
{
if( sock->recvPacketMap == NULL ) return false;
if( sock->recvPacketMap->empty() ) return false;
i3packet_t packet;
unsigned int length;
unsigned int flags;
unsigned int sequence;
int recvSize = sock->recvPacketMap->size();
while( 1 )
{
for( PacketMapItor itor = sock->recvPacketMap->begin(); itor != sock->recvPacketMap->end(); ++itor )
{
if( ((*itor).second)->sequence != sock->receiveSequence ) continue;
break;
}
if( itor == sock->recvPacketMap->end() || sock->recvPacketMap->size() == 0 ) return false;
memcpy( &packet, (*itor).second, sizeof( i3packet_t ) );
NET_DeletePacketBank( sock->recvPacketMap, packet.sequence );
length = packet.length & NETFLAG_LENGTH_MASK;
flags = packet.length >> 12;
sequence = packet.sequence;
length -= NET_HEADERSIZE;
sock->receiveSequence++;
memcpy(sock->receiveMessage + sock->receiveMessageLength, packet.data, length);
sock->receiveMessageLength += length;
if (flags & NETFLAG_EOM)
{
SZ_Clear(&recvMessage);
SZ_Write(&recvMessage, sock->receiveMessage, sock->receiveMessageLength);
sock->receiveMessageLength = 0;
return true;
}
}
return false;
}
int NET_ControlPacket_ReliableSocket( i3socket_t *sock, i3packet_t *packet )
{
unsigned int length;
unsigned int flags;
unsigned int sequence;
i3packet_t ackPacket;
int ret = PacketAnalysis_Skip;
int count;
sock->lastReceiveTime = g_netTime;
length = packet->length & NETFLAG_LENGTH_MASK;
flags = packet->length >> 12;
sequence = packet->sequence;
totalPacketsReceived ++;
if( flags & NETFLAG_ACK )
{
packetsAckReceived ++;
if( sock->sendPacketMap != NULL ) NET_DeletePacketBank( sock->sendPacketMap, sequence );
sock->latencyTime = sock->lastReceiveTime - sock->lastSendTime;
return ret = PacketAnalysis_Ack;
}
UINT datasize = length - NET_HEADERSIZE;
if ( packet->encrypt )
{
checksum packetsum;
packetsum.clear();
packetsum.add((BYTE*)packetBuffer.data, datasize);
if ( packetBuffer.checksum != packetsum.get() )
{
packetsDupCount++;
ret = PacketAnalysis_Skip;
return ret;
}
Crypt((TCHAR*)packet->data, datasize);
}
if (flags & NETFLAG_RELIABLE)
{
if( packet->lastSendTime != NET_SENDTIME_UNRELIABLE )
{
packetsReceived ++;
ackPacket.length = (NETFLAG_ACK << 12) | NET_HEADERSIZE;
ackPacket.sequence = sequence;
ackPacket.lastSendTime = g_netTime;
#ifndef _USE_SENDING_THREAD
NET_Write(sock->socket, (byte *)&ackPacket, NET_HEADERSIZE, &sock->addr);
#else
NET_WriteToSendingQueue(sock->socket, (byte *)&ackPacket, NET_HEADERSIZE, &sock->addr);
#endif
packetsAckSent ++;
lastRecvSequence = sequence;
myRecvSequence = sock->receiveSequence;
if( sequence == sock->receiveSequence )
{
sock->receiveSequence++;
length -= NET_HEADERSIZE;
memcpy(sock->receiveMessage + sock->receiveMessageLength, packet->data, length);
sock->receiveMessageLength += length;
if (flags & NETFLAG_EOM)
{
SZ_Clear(&recvMessage);
SZ_Write(&recvMessage, sock->receiveMessage, sock->receiveMessageLength);
sock->receiveMessageLength = 0;
ret = PacketAnalysis_Start;
}
else
{
ret = PacketAnalysis_Skip;
}
}
else if( sequence < sock->receiveSequence )
{
packetsDupCount++;
ret = PacketAnalysis_Skip;
}
else if( sequence > sock->receiveSequence )
{
packetsDropCount ++;
if( sock->recvPacketMap != NULL ) NET_InsertPacketBank( sock->recvPacketMap, packet );
ret = PacketAnalysis_Skip;
}
}
else
{
un_packetsReceived ++;
length -= NET_HEADERSIZE;
if (sequence != sock->unreliableReceiveSequence)
{
count = sequence - sock->unreliableReceiveSequence;
un_packetsDropCount += count;
}
sock->unreliableReceiveSequence = sequence + 1;
SZ_Clear (&recvMessage);
SZ_Write (&recvMessage, packet->data, length);
ret = PacketAnalysis_Start;
}
}
if( ret != PacketAnalysis_Start )
{
if( NET_ControlRecvBank( sock ) ) ret = PacketAnalysis_Start;
}
return ret;
}
int NET_ControlPacket_UnreliableSocket(i3socket_t *sock, i3packet_t *packet)
{
unsigned int length;
unsigned int flags;
unsigned int sequence;
i3packet_t ackPacket;
int ret = PacketAnalysis_None;
if( packet->length == 0 ) return PacketAnalysis_None;
sock->lastReceiveTime = g_netTime;
length = packet->length & NETFLAG_LENGTH_MASK;
flags = packet->length >> 12;
sequence = packet->sequence;
memset( &ackPacket, 0, sizeof( i3packet_t ) );
totalPacketsReceived ++;
if( flags & NETFLAG_ACK )
{
return ret = PacketAnalysis_Ack;
}
UINT datasize = length - NET_HEADERSIZE;
if ( packet->encrypt )
{
checksum packetsum;
packetsum.clear();
packetsum.add((BYTE*)packetBuffer.data, datasize);
if ( packetBuffer.checksum != packetsum.get() )
{
packetsDupCount++;
ret = PacketAnalysis_Skip;
return ret;
}
Crypt((TCHAR*)packet->data, datasize);
}
if (flags & NETFLAG_RELIABLE)
{
packetsReceived ++;
lastRecvSequence = sequence;
myRecvSequence = sock->receiveSequence;
sock->receiveSequence++;
length -= NET_HEADERSIZE;
if( sock->packetBlockSequence >= 0 )
{
if( sequence != sock->packetBlockSequence + 1 )
{
packetsDropCount++;
ret = PacketAnalysis_Skip;
if( flags & NETFLAG_EOM )
{
sock->receiveMessageLength = 0;
sock->packetBlockSequence = -1;
}
}
else
{
sock->packetBlockSequence ++;
memcpy(sock->receiveMessage + sock->receiveMessageLength, packet->data, length);
sock->receiveMessageLength += length;
if( flags & NETFLAG_EOM )
{
sock->packetBlockSequence = -1;
SZ_Clear(&recvMessage);
SZ_Write(&recvMessage, sock->receiveMessage, sock->receiveMessageLength);
sock->receiveMessageLength = 0;
ret = PacketAnalysis_Start;
}
else
{
ret = PacketAnalysis_Skip;
}
}
}
else if(flags & NETFLAG_SOM)
{
sock->packetBlockSequence = sequence;
memcpy(sock->receiveMessage + sock->receiveMessageLength, packet->data, length);
sock->receiveMessageLength += length;
ret = PacketAnalysis_Skip;
}
else if (flags & NETFLAG_EOM)
{
memcpy(sock->receiveMessage + sock->receiveMessageLength, packet->data, length);
sock->receiveMessageLength += length;
SZ_Clear(&recvMessage);
SZ_Write(&recvMessage, sock->receiveMessage, sock->receiveMessageLength);
sock->receiveMessageLength = 0;
ret = PacketAnalysis_Start;
}
else
{
ret = PacketAnalysis_Skip;
}
}
return ret;
}
int NET_ControlPacket(i3socket_t *sock, i3packet_t *packet)
{
if( sock->socketType == SocketType_Reliable )
return( NET_ControlPacket_ReliableSocket( sock, packet ) );
else
return( NET_ControlPacket_UnreliableSocket( sock, packet ) );
}
int NET_CheckSockProblem( i3socket_t *sock, int checkTime )
{
if( sock->sendPacketMap == NULL || sock->recvPacketMap == NULL ) return false;
if( sock->socketType == SocketType_Unreliable ) return true;
if( sock->sendPacketMap->size() > NET_MAXIMUM_PACKETMAP_SIZE || sock->recvPacketMap->size() > NET_MAXIMUM_PACKETMAP_SIZE )
{
return false;
}
if( checkTime < 0 ) return true;
if( g_netTime - sock->lastReceiveTime > checkTime )
{
return false;
}
return true;
}
int NET_Write (int socket, byte *buf, int len, struct sockaddr_in *addr)
{
int ret;
ret = sendto (socket, (char *)buf, len, 0, (struct sockaddr *)addr, sizeof(struct sockaddr_in));
if (ret == -1)
{
if (WSAGetLastError() == WSAEWOULDBLOCK)
{
return 0;
}
return 0;
}
return ret;
}
int NET_Read (int socket, byte *buf, int len, struct sockaddr_in *addr)
{
int addrlen = sizeof (struct sockaddr_in);
int ret;
ret = recvfrom (socket, (char *)buf, len, 0, (struct sockaddr *)addr, &addrlen);
if (ret == -1)
{
int errno = WSAGetLastError();
if (errno == WSAEWOULDBLOCK || errno == WSAECONNREFUSED)
{
return 0;
}
else
{
return 0;
}
}
return ret;
}
void NET_InitNetTime()
{
prevTime = curTime = timeGetTime();
g_netTime = 1;
}
unsigned int NET_GetNetTime()
{
unsigned int tempTime;
curTime = timeGetTime();
if (curTime >= prevTime)
{
g_netTime = g_netTime + (curTime - prevTime);
}
else
{
tempTime = (unsigned int)pow(2, 32) - prevTime;
g_netTime = g_netTime + tempTime + curTime;
}
prevTime = curTime;
return g_netTime;
}
void NET_InitPacketMap( i3socket_t *sock )
{
if( sock->sendPacketMap != NULL )
{
NET_ClearBank( sock->sendPacketMap );
delete sock->sendPacketMap;
sock->sendPacketMap = NULL;
}
if( sock->recvPacketMap != NULL )
{
NET_ClearBank( sock->recvPacketMap );
delete sock->recvPacketMap;
sock->recvPacketMap = NULL;
}
}
int NET_InitSocket(i3socket_t *sock, struct sockaddr_in *addr, int socket, int socketType)
{
NET_InitPacketMap( sock );
sock->socket = socket;
sock->socketType = socketType;
sock->connecttime = g_netTime;
sock->lastReceiveTime = g_netTime;
sock->lastSendTime = g_netTime;
sock->latencyTime = 0;
sock->disconnected = false;
sock->canSend = true;
sock->sendNext = false;
sock->resendSequence = 0;
sock->ackSequence = 0;
sock->sendSequence = 0;
sock->unreliableSendSequence = 0;
sock->sendMessageLength = 0;
sock->receiveSequence = 0;
sock->unreliableReceiveSequence = 0;
sock->receiveMessageLength = 0;
sock->packetBlockSequence = -1;
memcpy(&sock->addr, addr, sizeof(sockaddr_in));
sock->sendPacketMap = new PacketMap;
sock->recvPacketMap = new PacketMap;
sock->sendPacketMap->clear();
sock->recvPacketMap->clear();
return 1;
}
int NET_OpenNetwork()
{
WORD wVersionRequested;
WSADATA wsaData;
int i;
wVersionRequested = MAKEWORD( 2, 2 );
if (WSAStartup( wVersionRequested, &wsaData ) != 0 )
{
return false;
}
NET_InitNetTime();
SZ_Alloc(&netMessage, NET_MAXMESSAGE);
SZ_Alloc(&recvMessage, NET_MAXMESSAGE);
channelNumber = 0;
for (i=0; i<MAX_CHANNELS; i++)
channel[i] = -1;
runSendingThread = 0;
runReceivingThread = 0;
totalPacketsSend = 0;
totalPacketsReceived = 0;
packetsSent = 0;
packetsReceived = 0;
packetsReSent = 0;
packetsDropCount = 0;
packetsDupCount = 0;
packetsAckSent = 0;
packetsAckReceived = 0;
un_packetsSent = 0;
un_packetsReceived = 0;
un_packetsDropCount = 0;
InitializeCriticalSection( &spCrit );
return true;
}
int NET_OpenSocketForServer(i3socket_t *sock, char *serverIP, int port, int socketType )
{
SOCKET hSocket;
struct sockaddr_in addr;
unsigned long _true = 1;
hSocket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (hSocket == INVALID_SOCKET)
{
return 0;
}
if (ioctlsocket (hSocket, FIONBIO, &_true) == -1)
{
return 0;
}
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
if ( serverIP )
addr.sin_addr.s_addr = inet_addr(serverIP);
else
addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr.sin_port = htons( port );
if ( bind(hSocket, (LPSOCKADDR) &addr, sizeof(addr)) != 0 )
{
return 0;
}
NET_InitSocket(sock, &addr, hSocket, socketType);
if ( NET_AddListenChannel( sock->socket ) == 0 )
{
return 0;
}
sock->socketType = socketType;
return 1;
}
int NET_OpenSocketForClient(i3socket_t *sock, char *serverIP, int port, int socketType )
{
SOCKET hSocket;
struct sockaddr_in addr;
unsigned long _true = 1;
hSocket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (hSocket == INVALID_SOCKET)
{
return 0;
}
if (ioctlsocket (hSocket, FIONBIO, &_true) == -1)
{
return 0;
}
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr(serverIP);
addr.sin_port = htons( port );
NET_InitSocket(sock, &addr, hSocket, socketType);
if ( NET_AddListenChannel( sock->socket ) == 0 )
{
return 0;
}
sock->socketType = socketType;
return 1;
}
void NET_CloseSocket(i3socket_t *sock)
{
NET_DeleteListenChannel ( sock->socket );
closesocket(sock->socket);
sock->socket = INVALID_SOCKET;
}
void NET_ClearSocket(i3socket_t *sock)
{
if (sock->socket != INVALID_SOCKET)
{
closesocket(sock->socket);
sock->socket = INVALID_SOCKET;
}
}
void NET_CloseNetwork()
{
WSACleanup();
DeleteCriticalSection( &spCrit );
}
int NET_CreateSendingThread()
{
hSQMutex = CreateMutex(NULL, FALSE, NULL);
hThread = CreateThread(NULL, 0, NET_SendingThread, NULL, 0, &SendingThreadID);
if ( !hThread )
{
return 0;
}
CloseHandle(hThread);
return 1;
}
int NET_CreateReceivingThread()
{
hRQMutex = CreateMutex(NULL, FALSE, NULL);
hThread = CreateThread(NULL, 0, NET_ReceivingThread, NULL, 0, &ReceivingThreadID);
if ( !hThread )
{
return 0;
}
CloseHandle(hThread);
return 1;
}
DWORD WINAPI NET_SendingThread(LPVOID param)
{
int socket, len;
struct sockaddr_in addr;
i3packet_t buf;
if ( sendingQueue ) { delete sendingQueue; sendingQueue = NULL; }
sendingQueue = new CSendingQueue;
runSendingThread = 1;
while ( runSendingThread )
{
WaitForSingleObject(hSQMutex, INFINITE);
if (sendingQueue->m_count > 0)
{
sendingQueue->Pop(&socket, (byte *)&buf, &len, &addr);
NET_Write(socket, (byte *)&buf, len, &addr);
}
ReleaseMutex(hSQMutex);
}
CloseHandle(hSQMutex);
if ( sendingQueue ) { delete sendingQueue; sendingQueue = NULL; }
return 0;
}
DWORD WINAPI NET_ReceivingThread(LPVOID param)
{
int socket, len;
int addrlen = sizeof (struct sockaddr_in);
struct sockaddr_in addr;
i3packet_t buf;
int i;
if ( receivingQueue ) { delete receivingQueue; receivingQueue = NULL; }
receivingQueue = new CReceivingQueue;
runReceivingThread = 1;
while ( runReceivingThread )
{
for (i=0; i<channelNumber; i++)
{
socket = channel[i];
len = NET_Read(socket, (byte *)&buf, NET_DATAGRAMSIZE, &addr);
if (len > 0)
{
WaitForSingleObject(hRQMutex, INFINITE);
receivingQueue->Push(socket, (byte *)&buf, len, &addr);
ReleaseMutex(hRQMutex);
}
}
}
CloseHandle(hRQMutex);
if ( receivingQueue ) { delete receivingQueue; receivingQueue = NULL; }
return 0;
}
int NET_ReadFromReceivingQueue (int *socket, byte *buf, struct sockaddr_in *addr)
{
int len;
if ( !runReceivingThread ) return 0;
WaitForSingleObject(hRQMutex, INFINITE);
if (receivingQueue->m_count > 0)
{
receivingQueue->Pop(socket, buf, &len, addr);
}
else
len = 0;
ReleaseMutex(hRQMutex);
return len;
}
int NET_WriteToSendingQueue (int socket, byte *buf, int len, struct sockaddr_in *addr)
{
int ret;
if ( !runSendingThread ) return -1;
WaitForSingleObject(hSQMutex, INFINITE);
ret = sendingQueue->Push(socket, buf, len, addr);
ReleaseMutex(hSQMutex);
return ret;
}
void NET_DestroySendingThread()
{
runSendingThread = 0;
}
void NET_DestroyReceivingThread()
{
runReceivingThread = 0;
}
char *NET_ErrorString ()
{
int code;
code = WSAGetLastError ();
switch (code)
{
case WSAEINTR: return "WSAEINTR";
case WSAEBADF: return "WSAEBADF";
case WSAEACCES: return "WSAEACCES";
case WSAEDISCON: return "WSAEDISCON";
case WSAEFAULT: return "WSAEFAULT";
case WSAEINVAL: return "WSAEINVAL";
case WSAEMFILE: return "WSAEMFILE";
case WSAEWOULDBLOCK: return "WSAEWOULDBLOCK";
case WSAEINPROGRESS: return "WSAEINPROGRESS";
case WSAEALREADY: return "WSAEALREADY";
case WSAENOTSOCK: return "WSAENOTSOCK";
case WSAEDESTADDRREQ: return "WSAEDESTADDRREQ";
case WSAEMSGSIZE: return "WSAEMSGSIZE";
case WSAEPROTOTYPE: return "WSAEPROTOTYPE";
case WSAENOPROTOOPT: return "WSAENOPROTOOPT";
case WSAEPROTONOSUPPORT: return "WSAEPROTONOSUPPORT";
case WSAESOCKTNOSUPPORT: return "WSAESOCKTNOSUPPORT";
case WSAEOPNOTSUPP: return "WSAEOPNOTSUPP";
case WSAEPFNOSUPPORT: return "WSAEPFNOSUPPORT";
case WSAEAFNOSUPPORT: return "WSAEAFNOSUPPORT";
case WSAEADDRINUSE: return "WSAEADDRINUSE";
case WSAEADDRNOTAVAIL: return "WSAEADDRNOTAVAIL";
case WSAENETDOWN: return "WSAENETDOWN";
case WSAENETUNREACH: return "WSAENETUNREACH";
case WSAENETRESET: return "WSAENETRESET";
case WSAECONNABORTED: return "WSWSAECONNABORTEDAEINTR";
case WSAECONNRESET: return "WSAECONNRESET";
case WSAENOBUFS: return "WSAENOBUFS";
case WSAEISCONN: return "WSAEISCONN";
case WSAENOTCONN: return "WSAENOTCONN";
case WSAESHUTDOWN: return "WSAESHUTDOWN";
case WSAETOOMANYREFS: return "WSAETOOMANYREFS";
case WSAETIMEDOUT: return "WSAETIMEDOUT";
case WSAECONNREFUSED: return "WSAECONNREFUSED";
case WSAELOOP: return "WSAELOOP";
case WSAENAMETOOLONG: return "WSAENAMETOOLONG";
case WSAEHOSTDOWN: return "WSAEHOSTDOWN";
case WSASYSNOTREADY: return "WSASYSNOTREADY";
case WSAVERNOTSUPPORTED: return "WSAVERNOTSUPPORTED";
case WSANOTINITIALISED: return "WSANOTINITIALISED";
case WSAHOST_NOT_FOUND: return "WSAHOST_NOT_FOUND";
case WSATRY_AGAIN: return "WSATRY_AGAIN";
case WSANO_RECOVERY: return "WSANO_RECOVERY";
case WSANO_DATA: return "WSANO_DATA";
default: return "NO ERROR";
}
}
int NET_AddListenChannel( int socket )
{
if ( channelNumber < MAX_CHANNELS )
{
channel[channelNumber] = socket;
channelNumber ++;
}
else
{
return 0;
}
return 1;
}
int NET_DeleteListenChannel( int socket )
{
int i;
for (i=0; i<channelNumber; i++)
{
if ( channel[i] == socket )
{
if (i == channelNumber - 1)
channel[i] = -1;
else
channel[i] = channel[channelNumber];
channelNumber --;
return 1;
}
}
return 0;
}
int NET_ReadPacket(int *socket, byte *buf, struct sockaddr_in *addr)
{
int length;
#ifndef _USE_RECEIVING_THREAD
length = NET_Read(*socket, buf, NET_DATAGRAMSIZE, addr);
#else
length = NET_ReadFromReceivingQueue (socket, buf, addr);
#endif
return length;
}
int NET_PreviewMessage(i3packet_t *p)
{
int length;
length = p->length & NETFLAG_LENGTH_MASK;
length -= NET_HEADERSIZE;
if (length < 1) return false;
SZ_Clear (&recvMessage);
SZ_Write (&recvMessage, p->data, length);
return true;
}
void NET_SetMessageOption_EnableOverwriting(i3sizebuf_t *data, int identity)
{
data->overwriting = identity;
}
void MSG_Encrypt(i3sizebuf_t *sb, vec3_t v)
{
}
#include <tchar.h>
void Crypt(TCHAR *inp, DWORD inplen, TCHAR* key, DWORD keylen)
{
TCHAR Sbox[129], Sbox2[129];
unsigned long i, j, t, x;
static const TCHAR OurUnSecuredKey[] = "gth99comAAA" ;
static const int OurKeyLen = _tcslen(OurUnSecuredKey);
TCHAR temp , k;
i = j = k = t = x = 0;
temp = 0;
ZeroMemory(Sbox, sizeof(Sbox));
ZeroMemory(Sbox2, sizeof(Sbox2));
for(i = 0; i < 128U; i++)
{
Sbox[i] = (TCHAR)i;
}
j = 0;
if(keylen)
{
for(i = 0; i < 128U ; i++)
{
if(j == keylen)
{
j = 0;
}
Sbox2[i] = key[j++];
}
}
else
{
for(i = 0; i < 128U ; i++)
{
if(j == OurKeyLen)
{
j = 0;
}
Sbox2[i] = OurUnSecuredKey[j++];
}
}
j = 0 ;
for(i = 0; i < 128; i++)
{
j = (j + (unsigned long) Sbox[i] + (unsigned long) Sbox2[i]) % 128U ;
temp = Sbox[i];
Sbox[i] = Sbox[j];
Sbox[j] = temp;
}
i = j = 0;
for(x = 0; x < inplen; x++)
{
i = (i + 1U) % 128U;
j = (j + (unsigned long) Sbox[i]) % 128U;
temp = Sbox[i];
Sbox[i] = Sbox[j] ;
Sbox[j] = temp;
t = ((unsigned long) Sbox[i] + (unsigned long) Sbox[j]) % 128U ;
k = Sbox[t];
inp[x] = (inp[x] ^ k);
}
} | C++ |
#define SENDING_QUEUE_SIZE 3000
#define RECEIVING_QUEUE_SIZE 3000
typedef struct
{
int socket;
int len;
i3packet_t packet;
sockaddr_in addr;
} i3packetqueue_t;
class CSendingQueue
{
private:
int m_first;
int m_last;
int m_size;
int m_overflow;
i3packetqueue_t m_queue[SENDING_QUEUE_SIZE];
public:
int m_count;
int m_maxCount;
CSendingQueue();
~CSendingQueue();
int Push (int socket, byte *buf, int len, struct sockaddr_in *addr);
int Pop (int *socket, byte *buf, int *len, struct sockaddr_in *addr);
void Clear ();
};
class CReceivingQueue
{
private:
int m_first;
int m_last;
int m_size;
int m_overflow;
i3packetqueue_t m_queue[RECEIVING_QUEUE_SIZE];
public:
int m_count;
int m_maxCount;
CReceivingQueue();
~CReceivingQueue();
int Push (int socket, byte *buf, int len, struct sockaddr_in *addr);
int Pop (int *socket, byte *buf, int *len, struct sockaddr_in *addr);
void Clear ();
};
| C++ |
#include "netlib.h"
#include "queue.h"
#include <time.h>
i3sizebuf_t netMessage;
i3sizebuf_t recvMessage;
i3packet_t packetBuffer;
int msgReadCount;
int msgBadRead;
int totalPacketsSend;
int totalPacketsReceived;
int packetsSent;
int packetsReceived;
int packetsReSent;
int packetsDropCount;
int packetsDupCount;
int packetsAckSent;
int packetsAckReceived;
int un_packetsSent;
int un_packetsReceived;
int un_packetsDropCount;
unsigned int g_LastnetTime;
unsigned int g_netTime;
unsigned int prevTime, curTime;
int channel[ MAX_CHANNELS ];
int channelNumber;
HANDLE hThread;
DWORD SendingThreadID, ReceivingThreadID;
int runSendingThread, runReceivingThread;
CSendingQueue *sendingQueue;
CReceivingQueue *receivingQueue;
HANDLE hSQMutex, hRQMutex;
FILE *packetErrorLog;
int readSizePerSecond;
int lastRecvSequence;
int myRecvSequence;
CRITICAL_SECTION spCrit;
| C++ |
#if !defined(AFX_GAMETARGET_H__9E9D90B0_AA20_44AF_B54F_DFCB48AD4C47__INCLUDED_)
#define AFX_GAMETARGET_H__9E9D90B0_AA20_44AF_B54F_DFCB48AD4C47__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CGameTarget
{
public:
CGameTarget();
virtual ~CGameTarget();
Fx_CHARACTER_t* GTH_GetTargetPointer( Fx_CHARACTER_t* pThisChar );
Fx_CHARACTER_t* GTH_GetTargetPointer( int targetType, int targetIdx );
int GTH_GetTargetName( int targetType, int targetIdx, char *name );
void GTH_ChangeTarget( Fx_CHARACTER_t *character );
float GTH_GetTargetDistance( Fx_CHARACTER_t *pThisChar );
int GTH_GetTargetPosition( Fx_CHARACTER_t* pThisChar, vec3_t pos );
int GTH_GetTargetAlive( Fx_CHARACTER_t* pThisChar );
int GTH_GetTargetClientID( Fx_CHARACTER_t* pThisChar );
int GTH_SetAngleToTarget( Fx_CHARACTER_t* pThisChar );
int GTH_GetTargetServerIdxFromName( char* name );
int GTH_GetTargetPosition( int targetType, int targetIdx, vec3_t position );
};
extern CGameTarget g_GameTarget;
#endif
| C++ |
#include "global_def.h"
#include <Resapi.h>
#include "LogEvent.h"
CLogEvent gLogEvent;
CLogEvent::CLogEvent()
{
#ifdef _DEBUG
Init();
#endif
}
CLogEvent::~CLogEvent()
{
#ifdef _DEBUG
if(NULL != m_hEventSource)
{
::DeregisterEventSource(m_hEventSource);
}
#endif
}
void CLogEvent::Init()
{
#ifdef _DEBUG
m_hEventSource = NULL;
AddEventSource("GTH log","GTHGameserver",NULL,1);
m_hEventSource = ::RegisterEventSource(NULL,"GTH log");
#endif
}
BOOL CLogEvent::AddEventSource(
LPTSTR pszLogName,
LPTSTR pszSrcName,
LPTSTR pszMsgDLL,
DWORD dwNum)
{
HKEY hk;
DWORD dwData, dwDisp;
TCHAR szBuf[MAX_PATH];
wsprintf(szBuf,
"SYSTEM\\CurrentControlSet\\Services\\EventLog\\%s\\%s",
pszLogName, pszSrcName);
if (RegCreateKeyEx(HKEY_LOCAL_MACHINE, szBuf,
0, NULL, REG_OPTION_NON_VOLATILE,
KEY_WRITE, NULL, &hk, &dwDisp))
{
printf("Could not create the registry key.");
return FALSE;
}
if (RegSetValueEx(hk,
"EventMessageFile",
0,
REG_EXPAND_SZ,
(LPBYTE) pszMsgDLL,
(DWORD) lstrlen(pszMsgDLL)+1))
{
printf("Could not set the event message file.");
return FALSE;
}
dwData = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE |
EVENTLOG_INFORMATION_TYPE;
if (RegSetValueEx(hk,
"TypesSupported",
0,
REG_DWORD,
(LPBYTE) &dwData,
sizeof(DWORD)))
{
printf("Could not set the supported types.");
return FALSE;
}
if (RegSetValueEx(hk,
"CategoryMessageFile",
0,
REG_EXPAND_SZ,
(LPBYTE) pszMsgDLL,
(DWORD) lstrlen(pszMsgDLL)+1))
{
printf("Could not set the category message file.");
return FALSE;
}
if (RegSetValueEx(hk,
"CategoryCount",
0,
REG_DWORD,
(LPBYTE) &dwNum,
sizeof(DWORD)))
{
printf("Could not set the category count.");
return FALSE;
}
RegCloseKey(hk);
return TRUE;
}
void CLogEvent::WriteLog(WORD wType,const char* szMessage)
{
#ifdef _DEBUG
::ReportEvent(m_hEventSource,
wType,
1,
0,
NULL,
1,
0,
&szMessage,
NULL);
#endif
return;
}
void CLogEvent::LogEvent(WORD wType,LPCTSTR lpszFormat, ...)
{
#ifdef _DEBUG
va_list argList;
va_start(argList, lpszFormat);
char szOutputMessage[1024];
vsprintf(szOutputMessage,lpszFormat, argList);
va_end(argList);
WriteLog(wType,szOutputMessage);
#endif
}
void CLogEvent::ReStartLog()
{
::ClearEventLog(m_hEventSource,"gthlog.log");
} | C++ |
#include "core_def.h"
#include <stdio.h>
#include <string.h>
#include <TIME.H>
void Error( GTH_ERROR_TYPE error , char *str )
{
char szTemp[256];
sprintf( szTemp, "GTH Error : %s", str );
}
FILE *g_logFile;
char *g_logFilename = "../error.txt";
int g_logFirstWrite = true;
void ErrorLog( char* str, ... )
{
return;
char cTime[32];
time_t logtime;
char buf[4096];
va_list marker;
memset( buf, 0, sizeof( buf ) );
va_start( marker, str );
vsprintf( buf, str, marker);
time( &logtime );
strcpy( cTime, ctime( &logtime ) );
cTime[24] = '\0';
if( g_logFirstWrite )
{
g_logFile = fopen( g_logFilename, "wt" );
g_logFirstWrite = false;
}
else
{
g_logFile = fopen( g_logFilename, "at" );
}
fprintf( g_logFile, "[%s]\t%s\n", cTime, buf );
fclose( g_logFile );
}
| C++ |
#if !defined(AFX_D3DRENDER_H__7CEAC62E_8AEE_48E9_8275_B0ECA7D1E8EB__INCLUDED_)
#define AFX_D3DRENDER_H__7CEAC62E_8AEE_48E9_8275_B0ECA7D1E8EB__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include <d3dx8.h>
#include "shader.h"
class CD3DRender
{
public:
CD3DRender();
virtual ~CD3DRender();
DWORD m_format;
DWORD m_FogColor;
float m_FogStart;
float m_FogEnd;
bool m_bFog;
void InitDevice();
void SetTransform( D3DTRANSFORMSTATETYPE transType , matrix4x4_t *matrix );
void SetStreamSource( int numStream , LPDIRECT3DVERTEXBUFFER8 ptrVB , int sizeStride );
void SetVertexShader( DWORD format );
void SetIndices( LPDIRECT3DINDEXBUFFER8 ptrIB , int baseVertexIdx );
void SetTexture( int stage , LPDIRECT3DTEXTURE8 d3dTex );
void SetLight( int idxLight , light_t *light );
void SetMaterial( material_t *material );
void SetupVertexFog(DWORD color, float start, float end, DWORD mode = D3DFOG_LINEAR , int useRange = false , float density = 0.66f );
void SetupPixelFog(DWORD color, float start, float end, DWORD mode = D3DFOG_LINEAR , float density = 0.66f );
void SetFogEnable();
void SetFogDisable();
void SetSkyFogParameter(DWORD color , float start , float end);
void SetFogParameter(DWORD color, float start, float end);
void SetDefaultRenderState();
void ApplyDiffuseRenderState();
void ReleaseDiffuseRenderState();
void SetCustomRenderState();
void SetMDLRenderState();
void SetCharacterRenderState();
void SetShadowRenderState();
void SetDefaultRenderstates();
void RenderDefault( int baseVB , int sizeVB , int baseIB , int sizeRenderElems );
void RenderCustom( shader_t *shader , int baseVB , int sizeVB , int baseIB , int sizeRenderElems );
void RenderSky( shader_t *shader , int baseVB , int sizeVB , int baseIB , int sizeRenderElems );
void RenderMDLCustom( shader_t *shader , int baseVB , int sizeVB , int baseIB , int sizeRenderElems );
void SetAttachShader( DWORD color );
void EndAttachShader();
void RenderTransDefault( int baseVB , int sizeVB , int baseIB , int sizeRenderElems , DWORD color );
void RenderTransMDLCustom( shader_t *shader , int baseVB , int sizeVB , int baseIB , int sizeRenderElems , DWORD color );
};
#define SetD3DRGBA(a,b,c,d,e) { a.r=b; a.g=c; a.b=d; a.a=e; }
#define SetD3DVector(a,b,c,d) { a.x=b; a.y=c; a.z=d; }
extern CD3DRender g_d3dRender;
#endif
| C++ |
#include "bsp.h"
#include "camera.h"
#include "d3drender.h"
#include "d3dtexturemng.h"
#include "timer.h"
#include "d3ddevice.h"
void CBSP::RenderBefore()
{
shadermap_t *shaderMap;
shader_t *shader;
int i , j , size;
m_totalRenderPolygon = 0;
m_currBank = -1;
g_d3dRender.SetVertexShader( m_format );
g_d3dRender.SetIndices( m_dynamicIB->GetD3DIndexBuffer() , 0 );
m_dynamicIB->Discard();
m_dynamicVB->Discard();
g_d3dRender.SetDefaultRenderState();
size = m_shaderType->sizeDefault;
shaderMap = &m_shaderMaps[ m_shaderType->baseDefault ];
for( i = 0 ; i < size ; i++ , shaderMap++ )
{
if( shaderMap->frameFlag != m_frameFlag ) continue;
g_d3dRender.SetTexture( 0 , g_texMng.GetD3DTexture( shaderMap->shader ) );
for( j = 0 ; j < m_numLightmaps ; j++ )
{
if( shaderMap->LMFrameFlags[ j ] != m_frameFlag ) continue;
g_d3dRender.SetTexture( 1 , g_texMng.GetD3DTexture( m_lmapTexRefs[ j ] ) );
RenderDefault( &shaderMap->LMMaps[ j ] );
}
if( shaderMap->LMFrameFlags[ m_numLightmaps ] == m_frameFlag )
{
g_d3dRender.ApplyDiffuseRenderState();
RenderDefault( &shaderMap->LMMaps[ m_numLightmaps ] );
g_d3dRender.ReleaseDiffuseRenderState();
}
}
g_d3dRender.SetCustomRenderState();
size = m_shaderType->sizeCustom;
shaderMap = &m_shaderMaps[ m_shaderType->baseCustom ];
for( i = 0 ; i < size ; i++ , shaderMap++ )
{
if( shaderMap->frameFlag != m_frameFlag ) continue;
shader = &g_shaderMng.m_shaders[ shaderMap->shader ];
for( j = 0 ; j <= m_numLightmaps ; j++ )
{
if( shaderMap->LMFrameFlags[ j ] != m_frameFlag ) continue;
RenderCustom( shader , &shaderMap->LMMaps[ j ] , j );
}
}
g_d3dRender.SetStreamSource(0, m_dynamicVB->GetD3DVertexBuffer(), m_dynamicVB->GetStrideSize());
size = m_shaderType->sizeDeform;
shaderMap = &m_shaderMaps[ m_shaderType->baseDeform ];
for( i = 0 ; i < size ; i++ , shaderMap++ )
{
if( shaderMap->frameFlag != m_frameFlag ) continue;
shader = &g_shaderMng.m_shaders[ shaderMap->shader ];
for( j = 0 ; j <= m_numLightmaps ; j++ )
{
if( shaderMap->LMFrameFlags[ j ] != m_frameFlag ) continue;
RenderDeform( shader , &shaderMap->LMMaps[ j ] , j );
}
}
if(g_d3dRender.m_bFog)
{
D3DXMatrixPerspectiveFovLH((D3DXMATRIX*)&g_camera.m_projMat,
deg2rad(g_camera.m_projectParm.fov / g_camera.m_projectParm.aspect),
g_camera.m_projectParm.aspect,
g_camera.m_projectParm.znear,
100000.0f );
g_d3dDevice.GetD3DDevice()->SetTransform(D3DTS_PROJECTION, (D3DXMATRIX *)&g_camera.m_projMat );
D3DXMatrixPerspectiveFovLH((D3DXMATRIX*)&g_camera.m_projMat,
deg2rad( g_camera.m_projectParm.fov / g_camera.m_projectParm.aspect ),
g_camera.m_projectParm.aspect,
g_camera.m_projectParm.znear,
g_camera.m_projectParm.zfar );
g_d3dDevice.GetD3DDevice()->SetTransform( D3DTS_PROJECTION, (D3DXMATRIX *)&g_camera.m_projMat );
}
}
void CBSP::RenderAfter()
{
shadermap_t *shaderMap;
shader_t *shader;
int i , j , size;
m_currBank = -1;
g_d3dRender.SetVertexShader( m_format );
g_d3dRender.SetIndices( m_dynamicIB->GetD3DIndexBuffer() , 0 );
g_d3dRender.SetCustomRenderState();
size = m_shaderType->sizeTrans;
shaderMap = &m_shaderMaps[ m_shaderType->baseTrans ];
for( i = 0 ; i < size ; i++ , shaderMap++ )
{
if( shaderMap->frameFlag != m_frameFlag ) continue;
shader = &g_shaderMng.m_shaders[ shaderMap->shader ];
for( j = 0 ; j <= m_numLightmaps ; j++ )
{
if( shaderMap->LMFrameFlags[ j ] != m_frameFlag ) continue;
RenderCustom( shader , &shaderMap->LMMaps[ j ] , j );
}
}
g_d3dRender.SetStreamSource( 0 , m_dynamicVB->GetD3DVertexBuffer() , m_dynamicVB->GetStrideSize() );
size = m_shaderType->sizeDeformTrans;
shaderMap = &m_shaderMaps[ m_shaderType->baseDefromTrans ];
for( i = 0 ; i < size ; i++ , shaderMap++ )
{
if( shaderMap->frameFlag != m_frameFlag ) continue;
shader = &g_shaderMng.m_shaders[ shaderMap->shader ];
for( j = 0 ; j <= m_numLightmaps ; j++ )
{
if( shaderMap->LMFrameFlags[ j ] != m_frameFlag ) continue;
RenderDeform( shader , &shaderMap->LMMaps[ j ] , j );
}
}
}
#define GTH_SIZE_RENDER_FACE_PER_CALL 1000
inline void CBSP::RenderDefault( const shaderLMmap_t *LMMap )
{
int sizeRenderElems;
leafbaseface_t *face , *faceLoop;
face_t *renderFace;
WORD *ptrIB;
if( m_currBank != LMMap->bank )
{
g_d3dRender.SetStreamSource( 0 , m_staticVB[ LMMap->bank ]->GetD3DVertexBuffer()
, m_staticVB[ LMMap->bank ]->GetStrideSize() );
m_currBank = LMMap->bank;
}
faceLoop = LMMap->linked;
while( faceLoop )
{
sizeRenderElems = 0;
face = faceLoop;
while( face && sizeRenderElems <= GTH_SIZE_RENDER_FACE_PER_CALL )
{
sizeRenderElems += m_faces[ face->idxOriginFace ].sizeEB;
face = face->next;
}
if( sizeRenderElems <= 3 )
{
faceLoop = face;
continue;
}
ptrIB = (WORD *)m_dynamicIB->Lock( sizeRenderElems );
sizeRenderElems = 0;
face = faceLoop;
while( face && sizeRenderElems <= GTH_SIZE_RENDER_FACE_PER_CALL )
{
renderFace = &m_faces[ face->idxOriginFace ];
memcpy( ptrIB , &m_staticEB[ renderFace->offsetEB ] , renderFace->sizeEB * sizeof( WORD ) );
ptrIB += renderFace->sizeEB;
sizeRenderElems += renderFace->sizeEB;
face = face->next;
}
m_dynamicIB->Unlock();
m_totalRenderPolygon += sizeRenderElems / 3;
g_d3dRender.RenderDefault( LMMap->baseVB , LMMap->sizeVB , m_dynamicIB->GetBase() , sizeRenderElems );
faceLoop = face;
}
}
inline void CBSP::RenderCustom( shader_t *shader , const shaderLMmap_t *LMMap , const int idxLM )
{
int sizeRenderElems;
leafbaseface_t *face , *faceLoop;
face_t *renderFace;
WORD* ptrIB;
DWORD flags;
DWORD genRGBColor = 0x00000000;
DWORD genAlphaColor;
float color;
int i;
if( m_currBank != LMMap->bank )
{
g_d3dRender.SetStreamSource( 0 , m_staticVB[ LMMap->bank ]->GetD3DVertexBuffer()
, m_staticVB[ LMMap->bank ]->GetStrideSize() );
m_currBank = LMMap->bank;
}
faceLoop = LMMap->linked;
while( faceLoop )
{
sizeRenderElems = 0;
face = faceLoop;
while( face && sizeRenderElems <= GTH_SIZE_RENDER_FACE_PER_CALL )
{
sizeRenderElems += m_faces[ face->idxOriginFace ].sizeEB;
face = face->next;
}
if( sizeRenderElems <= 3 )
{
faceLoop = face;
continue;
}
ptrIB = (WORD *)m_dynamicIB->Lock( sizeRenderElems );
sizeRenderElems = 0;
face = faceLoop;
while( face && sizeRenderElems <= GTH_SIZE_RENDER_FACE_PER_CALL )
{
renderFace = &m_faces[ face->idxOriginFace ];
memcpy( ptrIB , &m_staticEB[ renderFace->offsetEB ] , renderFace->sizeEB * sizeof( WORD ) );
ptrIB += renderFace->sizeEB;
sizeRenderElems += renderFace->sizeEB;
face = face->next;
}
m_dynamicIB->Unlock();
shaderpass_t *pass = &shader->passes[0];
for( i = 0 ; i < shader->numPasses ; i++ , pass++ )
{
flags = pass->flags;
if( flags & SHADERPASS_MAP ){;}
else if( flags & SHADERPASS_MAP_LIGHTMAP )
{
if( idxLM != m_numLightmaps )
pass->texRef = m_lmapTexRefs[ idxLM ];
else
pass->texRef = g_texMng.GetWhiteImageRef();
}
else if( flags & SHADERPASS_MAP_ANIMMAP )
{
pass->texRef = pass->animMap->GetFrame( g_timer.GetAppTime() );
}
else if( flags & SHADERPASS_MAP_WHITEIMAGE )
{
pass->texRef = g_texMng.GetWhiteImageRef();
}
if( flags & SHADERPASS_RGBGEN )
{
if( pass->rgbGen.type == SHADERPASS_RGBGEN_WAVE )
{
color = g_shaderMng.EvaluateFunc( &pass->rgbGen.func , g_timer.GetAppTime() );
color *= 255.0f;
if( color < 0.0f ) color = 0.0f;
else if( color > 255.0f ) color = 255.0f;
genRGBColor = (DWORD) color;
pass->rgbGen.color = MAKE_COLOR_ARGB( 0xFF , genRGBColor , genRGBColor , genRGBColor );
}
else if( pass->rgbGen.type == SHADERPASS_RGBGEN_IDENTITY )
pass->rgbGen.color = MAKE_COLOR_ARGB( 0xFF , 0xFF , 0xFF , 0xFF );
}
if( flags & SHADERPASS_ALPHAGEN )
{
if( pass->alphaGen.type == SHADERPASS_RGBGEN_WAVE )
{
color = g_shaderMng.EvaluateFunc( &pass->alphaGen.func , g_timer.GetAppTime() );
color *= 255.0f;
if( color < 0.0f ) color = 0.0f;
else if( color > 255.0f ) color = 255.0f;
genAlphaColor = (DWORD) color;
pass->alphaGen.color = MAKE_COLOR_ARGB( genAlphaColor , genRGBColor , genRGBColor , genRGBColor );
}
else if( pass->alphaGen.type == SHADERPASS_RGBGEN_IDENTITY )
pass->alphaGen.color = MAKE_COLOR_ARGB( 0xFF , 0xFF , 0xFF , 0xFF );
}
if( flags & SHADERPASS_TCMOD )
g_shaderMng.EvaluateTcMod( pass , g_timer.GetAppTime() );
}
if( shader->flags & SHADER_TCGEN )
{
shader->tcGenMatrix.Identity();
shader->tcGenMatrix.zx -= g_camera.m_angles[YAW] / 360.0f;
shader->tcGenMatrix.zy -= g_camera.m_angles[PITCH] / 180.0f;
}
m_totalRenderPolygon += sizeRenderElems / 3;
g_d3dRender.RenderCustom(shader, LMMap->baseVB, LMMap->sizeVB, m_dynamicIB->GetBase(), sizeRenderElems);
faceLoop = face;
}
}
inline void CBSP::RenderSky( shader_t *shader , const shaderLMmap_t *LMMap , const int idxLM )
{
int sizeRenderElems;
leafbaseface_t *face , *faceLoop;
face_t *renderFace;
WORD* ptrIB;
DWORD flags;
DWORD genRGBColor = 0x00000000;
DWORD genAlphaColor;
float color;
int i;
if( m_currBank != LMMap->bank )
{
g_d3dRender.SetStreamSource( 0 , m_staticVB[ LMMap->bank ]->GetD3DVertexBuffer()
, m_staticVB[ LMMap->bank ]->GetStrideSize() );
m_currBank = LMMap->bank;
}
faceLoop = LMMap->linked;
while( faceLoop )
{
sizeRenderElems = 0;
face = faceLoop;
while( face && sizeRenderElems <= GTH_SIZE_RENDER_FACE_PER_CALL )
{
sizeRenderElems += m_faces[ face->idxOriginFace ].sizeEB;
face = face->next;
}
if( sizeRenderElems <= 3 )
{
faceLoop = face;
continue;
}
ptrIB = (WORD *)m_dynamicIB->Lock( sizeRenderElems );
sizeRenderElems = 0;
face = faceLoop;
while( face && sizeRenderElems <= GTH_SIZE_RENDER_FACE_PER_CALL )
{
renderFace = &m_faces[ face->idxOriginFace ];
memcpy( ptrIB , &m_staticEB[ renderFace->offsetEB ] , renderFace->sizeEB * sizeof( WORD ) );
ptrIB += renderFace->sizeEB;
sizeRenderElems += renderFace->sizeEB;
face = face->next;
}
m_dynamicIB->Unlock();
shaderpass_t *pass = &shader->passes[0];
for( i = 0 ; i < shader->numPasses ; i++ , pass++ )
{
flags = pass->flags;
if( flags & SHADERPASS_MAP ){;}
else if( flags & SHADERPASS_MAP_LIGHTMAP )
{
if( idxLM != m_numLightmaps )
pass->texRef = m_lmapTexRefs[ idxLM ];
else
pass->texRef = g_texMng.GetWhiteImageRef();
}
else if( flags & SHADERPASS_MAP_ANIMMAP )
{
pass->texRef = pass->animMap->GetFrame( g_timer.GetAppTime() );
}
else if( flags & SHADERPASS_MAP_WHITEIMAGE )
{
pass->texRef = g_texMng.GetWhiteImageRef();
}
if( flags & SHADERPASS_RGBGEN )
{
if( pass->rgbGen.type == SHADERPASS_RGBGEN_WAVE )
{
color = g_shaderMng.EvaluateFunc( &pass->rgbGen.func , g_timer.GetAppTime() );
color *= 255.0f;
if( color < 0.0f ) color = 0.0f;
else if( color > 255.0f ) color = 255.0f;
genRGBColor = (DWORD) color;
pass->rgbGen.color = MAKE_COLOR_ARGB( 0xFF , genRGBColor , genRGBColor , genRGBColor );
}
else if( pass->rgbGen.type == SHADERPASS_RGBGEN_IDENTITY )
pass->rgbGen.color = MAKE_COLOR_ARGB( 0xFF , 0xFF , 0xFF , 0xFF );
}
if( flags & SHADERPASS_ALPHAGEN )
{
if( pass->alphaGen.type == SHADERPASS_RGBGEN_WAVE )
{
color = g_shaderMng.EvaluateFunc( &pass->alphaGen.func , g_timer.GetAppTime() );
color *= 255.0f;
if( color < 0.0f ) color = 0.0f;
else if( color > 255.0f ) color = 255.0f;
genAlphaColor = (DWORD) color;
pass->alphaGen.color = MAKE_COLOR_ARGB( genAlphaColor , genRGBColor , genRGBColor , genRGBColor );
}
else if( pass->alphaGen.type == SHADERPASS_RGBGEN_IDENTITY )
pass->alphaGen.color = MAKE_COLOR_ARGB( 0xFF , 0xFF , 0xFF , 0xFF );
}
if( flags & SHADERPASS_TCMOD )
g_shaderMng.EvaluateTcMod( pass , g_timer.GetAppTime() );
}
if( shader->flags & SHADER_TCGEN )
{
shader->tcGenMatrix.Identity();
shader->tcGenMatrix.zx -= g_camera.m_angles[YAW] / 360.0f;
shader->tcGenMatrix.zy -= g_camera.m_angles[PITCH] / 180.0f;
}
m_totalRenderPolygon += sizeRenderElems / 3;
g_d3dRender.RenderSky(shader, LMMap->baseVB, LMMap->sizeVB, m_dynamicIB->GetBase(), sizeRenderElems);
faceLoop = face;
}
}
inline void CBSP::RenderDeform( shader_t *shader , const shaderLMmap_t *LMMap , const int idxLM )
{
int sizeRenderElems;
int sizeRenderVerts;
leafbaseface_t *face , *faceLoop;
face_t *renderFace;
WORD *ptrIB , *elem;
vertex_t *ptrVB;
WORD baseIdxVB;
DWORD flags;
DWORD genRGBColor = 0x00000000;
DWORD genAlphaColor;
vec3_t tmpVect;
vertex_t *vert;
float color , offset , deflect;
int i , size;
faceLoop = LMMap->linked;
while( faceLoop )
{
sizeRenderVerts = 0;
sizeRenderElems = 0;
face = faceLoop;
while( face && sizeRenderElems <= GTH_SIZE_RENDER_FACE_PER_CALL )
{
sizeRenderVerts += m_faces[ face->idxOriginFace ].sizeVB;
sizeRenderElems += m_faces[ face->idxOriginFace ].sizeEB;
face = face->next;
}
if( sizeRenderElems <= 3 )
{
faceLoop = face;
continue;
}
ptrVB = (vertex_t *) m_dynamicVB->Lock( sizeRenderVerts );
ptrIB = (WORD *) m_dynamicIB->Lock( sizeRenderElems );
baseIdxVB = m_dynamicVB->GetBase();
sizeRenderVerts = 0;
sizeRenderElems = 0;
face = faceLoop;
while( face && sizeRenderElems <= GTH_SIZE_RENDER_FACE_PER_CALL )
{
renderFace = &m_faces[ face->idxOriginFace ];
vert = &m_deformVB[ renderFace->offsetVB ];
size = renderFace->sizeVB;
for( i = 0 ; i < size ; i++ , ptrVB++ , vert++ )
{
offset = ( vert->point[0] + vert->point[1] + vert->point[2] ) * shader->deform.div;
deflect = g_shaderMng.EvaluateFunc( &shader->deform.func , offset , g_timer.GetAppTime() );
VectorCopy ( tmpVect , vert->normal );
VectorScale( tmpVect , tmpVect , deflect );
VectorAdd ( tmpVect , tmpVect , vert->point );
VectorCopy ( ptrVB->point , tmpVect );
VectorCopy ( ptrVB->normal , vert->normal );
Vector2Copy( ptrVB->texUV , vert->texUV );
Vector2Copy( ptrVB->lmapUV , vert->lmapUV );
ColorCopy ( ptrVB->diffuse , vert->diffuse );
}
size = renderFace->sizeEB;
elem = &m_staticEB[ renderFace->offsetEB ];
for( i = 0 ; i < size ; i++ , ptrIB++ , elem++ )
*ptrIB = *elem + baseIdxVB;
baseIdxVB += renderFace->sizeVB;
sizeRenderVerts += renderFace->sizeVB;
sizeRenderElems += renderFace->sizeEB;
face = face->next;
}
m_dynamicVB->Unlock();
m_dynamicIB->Unlock();
shaderpass_t *pass = &shader->passes[0];
for( i = 0 ; i < shader->numPasses ; i++ , pass++ )
{
flags = pass->flags;
if( flags & SHADERPASS_MAP ){;}
else if( flags & SHADERPASS_MAP_LIGHTMAP )
{
if( idxLM != m_numLightmaps )
pass->texRef = m_lmapTexRefs[ idxLM ];
else
pass->texRef = g_texMng.GetWhiteImageRef();
}
else if( flags & SHADERPASS_MAP_ANIMMAP )
{
pass->texRef = pass->animMap->GetFrame( g_timer.GetAppTime() );
}
else if( flags & SHADERPASS_MAP_WHITEIMAGE )
{
pass->texRef = g_texMng.GetWhiteImageRef();
}
if( flags & SHADERPASS_RGBGEN )
{
if( pass->rgbGen.type == SHADERPASS_RGBGEN_WAVE )
{
color = g_shaderMng.EvaluateFunc( &pass->rgbGen.func , g_timer.GetAppTime() );
color *= 255.0f;
if( color < 0.0f ) color = 0.0f;
else if( color > 255.0f ) color = 255.0f;
genRGBColor = (DWORD) color;
pass->rgbGen.color = MAKE_COLOR_ARGB( 0xFF , genRGBColor , genRGBColor , genRGBColor );
}
else if( pass->rgbGen.type == SHADERPASS_RGBGEN_IDENTITY )
pass->rgbGen.color = MAKE_COLOR_ARGB( 0xFF , 0xFF , 0xFF , 0xFF );
}
if( flags & SHADERPASS_ALPHAGEN )
{
if( pass->alphaGen.type == SHADERPASS_RGBGEN_WAVE )
{
color = g_shaderMng.EvaluateFunc( &pass->alphaGen.func , g_timer.GetAppTime() );
color *= 255.0f;
if( color < 0.0f ) color = 0.0f;
else if( color > 255.0f ) color = 255.0f;
genAlphaColor = (DWORD) color;
pass->alphaGen.color = MAKE_COLOR_ARGB( genAlphaColor , genRGBColor , genRGBColor , genRGBColor );
}
else if( pass->alphaGen.type == SHADERPASS_RGBGEN_IDENTITY )
pass->alphaGen.color = MAKE_COLOR_ARGB( 0xFF , 0xFF , 0xFF , 0xFF );
}
if( flags & SHADERPASS_TCMOD )
g_shaderMng.EvaluateTcMod( pass , g_timer.GetAppTime() );
}
if( shader->flags & SHADER_TCGEN )
{
shader->tcGenMatrix.Identity();
shader->tcGenMatrix.zx -= g_camera.m_angles[ YAW ] / 360.0f;
shader->tcGenMatrix.zy -= g_camera.m_angles[ PITCH ] / 180.0f;
}
m_totalRenderPolygon += sizeRenderElems / 3;
g_d3dRender.RenderCustom( shader , m_dynamicVB->GetBase() , sizeRenderVerts , m_dynamicIB->GetBase() , sizeRenderElems );
faceLoop = face;
}
}
| C++ |
#include <stdio.h>
#include "core_def.h"
#include "d3dtexturemng.h"
#include "d3ddevice.h"
#include "filemng.h"
#include "ResourceCounter.h"
#include "../DebuggingLog/VUtil.h"
#include <assert.h>
CD3DTextureMng g_texMng;
CTextureResource::CTextureResource()
{
Clear();
m_owner = 0;
m_loaded = 0;
m_width = 0;
m_height = 0;
m_size = 0;
m_bits = 0;
m_mipLevel = 0;
m_hasAlpha = 0;
m_minFilter = 0;
m_magFilter = 0;
m_mipFilter = 0;
m_addrMode = 0;
}
CTextureResource::~CTextureResource()
{
Dispose();
}
bool CTextureResource::UploadTexture()
{
CTextureResource *texture = this;
HRESULT hr;
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
D3DFORMAT format = ( texture->m_bits == 32 ) ? D3DFMT_A8R8G8B8 : D3DFMT_A4R4G4B4;
D3DXIMAGE_INFO info;
D3DSURFACE_DESC desc;
D3DLOCKED_RECT rect;
D3DXIMAGE_INFO imageinfo;
hr = D3DXGetImageInfoFromFileInMemory( texture->m_data, texture->m_size, &imageinfo );
if( FAILED( hr ) )
{
texture->Dispose();
return false;
}
if( imageinfo.ImageFileFormat == D3DXIFF_DDS )
{
hr = D3DXCreateTextureFromFileInMemoryEx(
pd3dDevice ,
texture->m_data ,
texture->m_size ,
imageinfo.Width ,
imageinfo.Height ,
imageinfo.MipLevels ,
0 ,
imageinfo.Format ,
D3DPOOL_MANAGED ,
D3DX_FILTER_TRIANGLE ,
D3DX_FILTER_NONE ,
0 ,
&info ,
NULL ,
&texture->m_d3dTex );
}
else
{
hr = D3DXCreateTextureFromFileInMemoryEx(
pd3dDevice ,
texture->m_data,
texture->m_size,
( texture->m_width ) ? texture->m_width : D3DX_DEFAULT ,
( texture->m_height ) ? texture->m_height : D3DX_DEFAULT ,
( texture->m_mipLevel > 1 ) ? D3DX_DEFAULT : 1 ,
0 ,
format ,
D3DPOOL_MANAGED ,
D3DX_FILTER_TRIANGLE ,
D3DX_FILTER_BOX ,
0 ,
&info ,
NULL ,
&texture->m_d3dTex );
}
if( FAILED( hr ) )
{
texture->Dispose();
return false;
}
if( texture->m_hasAlpha && info.Format != D3DFMT_A8R8G8B8 )
{
if( SUCCEEDED( texture->m_d3dTex->GetLevelDesc( 0 , &desc ) ) )
{
if( SUCCEEDED( texture->m_d3dTex->LockRect( 0 , &rect , 0 , 0 ) ) )
{
BYTE* d = (BYTE*) rect.pBits;
for( DWORD y = 0 ; y < desc.Height ; y++ )
{
DWORD *dst = (DWORD*) d;
BYTE *s = d;
for( DWORD x = 0 ; x < desc.Width ; x++ ) {
DWORD r , g , b , a;
r =(DWORD) s[2];
g =(DWORD) s[1];
b =(DWORD) s[0];
a =(r+g+b) / 3 ;
dst[x] = ( a << 24 ) | ( r << 16 ) | ( g << 8 ) | b;
s += 4;
}
d += rect.Pitch;
}
texture->m_d3dTex->UnlockRect(0);
}
}
}
GTH_SAFE_FREE( texture->m_data );
return true;
}
bool CTextureResource::Create( char* fname, int iSize )
{
m_data = g_fileMng.ReadFileFromPack( m_name );
m_size = iSize;
if( !m_data ) return false;
UploadTexture();
return true;
}
bool CTextureResource::Recreate()
{
m_data = g_fileMng.ReadFileFromPack( m_name );
if( !m_data ) return false;
UploadTexture();
return true;
}
CD3DTextureMng::CD3DTextureMng()
{
m_texQuality = GTH_TEXTURE_QUALITY_HIGH;
m_numTextures = 0;
MEMORYSTATUS memStatus;
GlobalMemoryStatus( &memStatus );
if( memStatus.dwTotalPhys < 267870208 )
{
m_textureRscSize = 31457280;
}
else
{
m_textureRscSize = 31457280 * 2;
}
m_resManager.Create( m_textureRscSize );
}
CD3DTextureMng::~CD3DTextureMng()
{
}
void CD3DTextureMng::Release()
{
int i;
for( i = 0 ; i < m_numTextures ; i++ )
{
m_textures[i].Dispose();
m_resManager.RemoveResource( (RHANDLE)&m_textures[i] );
}
m_numTextures = 0;
m_resManager.Create( m_textureRscSize );
}
void CD3DTextureMng::Release( int owner )
{
int i;
for( i = 0 ; i < m_numTextures ; i++ )
{
if( m_textures[ i ].m_owner & owner )
{
m_textures[ i ].m_owner &= ~owner;
if( !m_textures[ i ].m_owner )
{
m_textures[i].Dispose();
m_resManager.RemoveResource( (RHANDLE)&m_textures[i] );
}
}
}
}
void CD3DTextureMng::Release( char *name , int owner )
{
int i;
for( i = 0 ; i < m_numTextures ; i++ )
{
if( !stricmp( m_textures[ i ].m_name , name ) )
{
m_textures[ i ].m_owner &= ~owner;
if( !m_textures[ i ].m_owner )
{
m_textures[i].Dispose();
m_resManager.RemoveResource( (RHANDLE)&m_textures[i] );
}
return;
}
}
}
void CD3DTextureMng::Release( int idxTex , int owner )
{
m_textures[idxTex].m_owner &= ~owner;
if( !m_textures[idxTex].m_owner )
{
m_textures[idxTex].Dispose();
m_resManager.RemoveResource( (RHANDLE)&m_textures[idxTex] );
}
}
void CD3DTextureMng::Restore()
{
CTextureResource *texture;
char texName[256];
char fName[256];
char *ext;
g_fileMng.SetResourceManager( &m_resManager );
for( int i = 0 ; i < m_numTextures ; i++ )
{
texture = &m_textures[ i ];
strcpy( texName , texture->m_name );
strcpy( fName, texName );
if( ext = CFileMng::GetFileExt( fName ) )
strcpy( ext , "dds" );
else
strcat( fName , ".dds" );
strcpy( texture->m_name, fName );
if( !g_fileMng.RegisterFileFromPack( texture->m_name, (RHANDLE)texture, texture, RES_INIT_NOTCREATE ) )
{
strcpy( fName , texName );
if( ext = CFileMng::GetFileExt( fName ) )
strcpy( ext , "jpg" );
else
strcat( fName , ".jpg" );
strcpy( texture->m_name, fName );
if( !g_fileMng.RegisterFileFromPack( texture->m_name, (RHANDLE)texture, texture, RES_INIT_NOTCREATE ) )
{
strcpy( fName , texName );
if( ext = CFileMng::GetFileExt( fName ) )
strcpy( ext , "tga" );
else
strcat( fName , ".tga" );
strcpy( texture->m_name, fName );
if( !g_fileMng.RegisterFileFromPack( texture->m_name, (RHANDLE)texture, texture, RES_INIT_NOTCREATE ) )
{
continue;
}
}
}
}
}
int CD3DTextureMng::Search( char *name , int owner )
{
int i;
char *fn1, *fn2;
char comparen1[256], comparen2[256];
for( i = 0 ; i < m_numTextures ; i++ )
{
strcpy( comparen1, m_textures[ i ].m_name );
if( m_texQuality == GTH_TEXTURE_QUALITY_LOW &&
( owner != OWNER_TYPE_INTERFACE && owner != OWNER_TYPE_BSP_LIGHTMAP ) )
{
sprintf( comparen2 , "low_" );
strcat( comparen2 , name );
}
else
{
strcpy( comparen2, name );
}
fn1 = CFileMng::GetFileNameOnly( comparen1 );
fn2 = CFileMng::GetFileNameOnly( comparen2 );
if( !stricmp( fn1, fn2 ) )
{
m_textures[ i ].m_owner |= owner;
return i;
}
}
return -1;
}
LPDIRECT3DTEXTURE8 CD3DTextureMng::GetD3DTexture( int texRef )
{
CTextureResource *texture = &m_textures[texRef];
bool bIsDisposed = texture->IsDisposed();
if( m_resManager.GetResource( (RHANDLE)texture ) == NULL )
{
return NULL;
}
if( bIsDisposed )
{
}
return m_textures[texRef].m_d3dTex;
}
void CD3DTextureMng::AddWhiteImage()
{
memset( m_whiteImage , 0xFF , sizeof( DWORD ) * 16 * 16 );
m_whiteImageRef = Add( "whiteimage" , OWNER_TYPE_BSP | OWNER_TYPE_MODEL | OWNER_TYPE_CHARACTER
, 16 * 16 * 4 , (BYTE *) m_whiteImage , 32 , false , 1 , true , 16 , 16 );
}
int CD3DTextureMng::Add( char *name , int owner , int size , BYTE *data
, int bits , int wrap , int mipLevel , int hasAlpha
, int width , int height )
{
assert(m_numTextures <= MAX_SIZE_TEXTURE);
int i;
char *fn1, *fn2;
char comparen1[256], comparen2[256];
CTextureResource *texture;
if(m_numTextures >= MAX_SIZE_TEXTURE)
int count = 0;
for( i = 0 ; i < m_numTextures ; i++ )
{
strcpy( comparen1, m_textures[ i ].m_name );
if( m_texQuality == GTH_TEXTURE_QUALITY_LOW &&
( owner != OWNER_TYPE_INTERFACE && owner != OWNER_TYPE_BSP_LIGHTMAP ) )
{
sprintf( comparen2 , "low_" );
strcat( comparen2 , name );
}
else
{
strcpy( comparen2, name );
}
fn1 = CFileMng::GetFileNameOnly( comparen1 );
fn2 = CFileMng::GetFileNameOnly( comparen2 );
if( !stricmp( fn1, fn2 ) )
{
m_textures[ i ].m_owner |= owner;
return i;
}
}
texture = &m_textures[ m_numTextures ];
texture->m_owner = owner;
texture->m_data = data;
texture->m_size = size;
texture->m_width = width;
texture->m_height = height;
texture->m_hasAlpha = hasAlpha;
texture->m_mipLevel = mipLevel;
texture->m_bits = bits;
texture->m_minFilter = D3DTEXF_LINEAR;
texture->m_magFilter = D3DTEXF_LINEAR;
texture->m_mipFilter = ( mipLevel > 1 ) ? D3DTEXF_POINT : D3DTEXF_NONE;
texture->m_addrMode = ( wrap ) ? D3DTADDRESS_WRAP : D3DTADDRESS_CLAMP;
if( m_texQuality == GTH_TEXTURE_QUALITY_LOW &&
( owner != OWNER_TYPE_INTERFACE && owner != OWNER_TYPE_BSP_LIGHTMAP ) )
{
sprintf( texture->m_name, "low_" );
strcat( texture->m_name, name );
}
else
{
strcpy( texture->m_name, name );
}
texture->m_d3dTex = NULL;
m_numTextures++;
return m_numTextures - 1;
}
| C++ |
#ifndef _D3DBUFFER_H
#define _D3DBUFFER_H
#include <d3dx8.h>
typedef enum
{
GTH_VERTEX_BUFFER = 1 << 0 ,
GTH_INDEX_BUFFER = 1 << 1 ,
GTH_STATIC_BUFFER = 1 << 2 ,
GTH_DYNAMIC_BUFFER = 1 << 3 ,
GTH_WRITEONLY = 1 << 4
} GTH_BUFFERTYPE;
typedef enum
{
GTH_FORMAT_XYZ = 1 << 0 ,
GTH_FORMAT_XYZRHW = 1 << 1 ,
GTH_FORMAT_NORMAL = 1 << 2 ,
GTH_FORMAT_DIFFUSE = 1 << 3 ,
GTH_FORMAT_SPECULAR = 1 << 4 ,
GTH_FORMAT_TEXVERTEXFLAG = 1 << 16
} GTH_VERTEXBUFFERFORMAT;
typedef enum
{
GTH_FORMAT_INDEX16 = 1 << 0 ,
GTH_FORMAT_INDEX32 = 1 << 1
} GTH_INDEXBUFFERFORMAT;
#define GTH_FORMAT_TEXVERTEX( size ) ( GTH_FORMAT_TEXVERTEXFLAG | ( size << 8 ) )
class CD3DBuffer
{
public:
CD3DBuffer();
~CD3DBuffer();
void Release();
int Create( int size, DWORD format, DWORD bufType );
void Discard();
BYTE *Lock( const int sizeToLock = 0 );
void Unlock();
int CheckFreeSize( int sizeToLock );
int isLocked() { return m_isLocked; }
BYTE *GetBuffer() { return m_ptrBuffer; }
int GetBase() { return m_base; }
int GetStrideSize() { return m_strideSize; }
LPDIRECT3DVERTEXBUFFER8 GetD3DVertexBuffer() { return m_pD3DVertexBuffer; }
LPDIRECT3DINDEXBUFFER8 GetD3DIndexBuffer() { return m_pD3DIndexBuffer; }
private:
int CreateIndexBuffer( int size, DWORD format, DWORD bufType );
int CreateVertexBuffer( int size, DWORD format, DWORD bufType );
inline BYTE *LockVertexBuffer( const int sizeToLock );
inline BYTE *LockIndexBuffer( const int sizeToLock );
LPDIRECT3DVERTEXBUFFER8 m_pD3DVertexBuffer;
LPDIRECT3DINDEXBUFFER8 m_pD3DIndexBuffer;
DWORD m_type;
DWORD m_format;
int m_maxSize;
int m_usedSize;
int m_strideSize;
int m_base;
BYTE *m_ptrBuffer;
int m_isLocked;
unsigned long m_offsetVertex;
unsigned long m_strideVertex;
unsigned long m_offsetNormal;
unsigned long m_offsetDiffuse;
unsigned long m_offsetSpecular;
unsigned long m_offsetTexVertex;
unsigned long m_strideTexVertex;
int m_nTexVertex;
};
#endif
| C++ |
#ifndef _DISPLAY_H
#define _DISPLAY_H
class CDisplay
{
struct sDisplayParams
{
float Contrast;
float Gamma;
float Brightness;
sDisplayParams()
{
Contrast = 1.0f;
Gamma = 1.3f;
Brightness = 0.6f;
}
};
sDisplayParams m_DisplayParams;
public:
CDisplay();
~CDisplay();
int m_gammaRampType;
void SetupGamma();
float GetBrightness() const { return m_DisplayParams.Brightness; }
float GetGamma() const { return m_DisplayParams.Gamma; }
float GetContrast() const { return m_DisplayParams.Contrast; }
void SetBrightness(float Brightness) { m_DisplayParams.Brightness = Brightness; }
void SetGamma(float Gamma) { m_DisplayParams.Gamma = Gamma; }
void SetContrast(float Contrast) { m_DisplayParams.Contrast = Contrast; }
};
extern CDisplay g_display;
#endif | C++ |
#ifndef _TIMER_H
#define _TIMER_H
#include <windows.h>
class CTimer
{
public:
int m_stopped;
int m_inited;
int m_usingQPF;
double m_lastElapsedTime;
double m_baseTime;
double m_stopTime;
double m_currSysTime;
double m_currElapsedTime;
double m_baseMilliTime;
double m_currSysMilliTime;
double m_currElapsedMilliTime;
LONGLONG m_QPFTicksPerSec;
LONGLONG m_QPFStopTime;
LONGLONG m_QPFLastElapsedTime;
LONGLONG m_QPFBaseTime;
LARGE_INTEGER m_QPFTime;
public:
CTimer();
virtual ~CTimer();
void Start();
void Stop();
void Advance();
void Reset();
float Tick();
inline float GetAppTime() { return (float) ( m_currSysTime - m_baseTime ); }
inline float GetElapsedTime() { return (float) m_currElapsedTime; }
inline float GetSysTime() { return (float) m_currSysTime; }
inline float GetAppMilliTime() { return (float) ( m_currSysMilliTime - m_baseMilliTime ); }
inline float GetElapsedMilliTime() { return (float) m_currElapsedMilliTime; }
float GetAbsoluteTime();
};
extern CTimer g_timer;
#endif
| C++ |
#ifndef _FX_DECAL_H_ALKJASD0923804980234S
#define _FX_DECAL_H_ALKJASD0923804980234S
#include "../math/math.h"
#include "gth_bsp.h"
#include <d3dx8.h>
#define SHADOW_VERTEX_BUFFER_SIZE 2000
typedef struct
{
vec3_t pos;
float tu, tv;
} shadow_vertex_t;
class CFXDecal
{
public:
CFXDecal ();
virtual ~CFXDecal ();
public:
inline void SetInvTransformMatrix ( matrix4x4_t *in_matrix ) { D3DXMatrixInverse ( (D3DXMATRIX *)&m_invTransform, NULL, (D3DXMATRIX *)in_matrix ); };
inline void SetVertices ( vertex_t *in_vertices ) { m_vertices = in_vertices; };
inline void SetIndices ( element_t *in_indices ) { m_indices = in_indices; };
inline void SetLight ( vec3_t &in_light ) { VectorCopy ( m_light, in_light ); };
inline void SetSize ( float in_size ) { m_halfLength = in_size; };
void Initialize ();
void Setup ( matrix4x4_t *in_matrix, vertex_t *in_vertices, element_t *in_indices, vec3_t &in_light, float in_size );
void SetMinMaxHeight ( float in_minHeight, float in_maxHeight ) { m_minHeight = in_minHeight; m_maxHeight = in_maxHeight; };
inline void SetSunLight ( vec3_t &in_sunLight ) { VectorCopy ( m_sunLight, in_sunLight ); VectorNormalize2 ( m_normLight, in_sunLight ); };
bool Process ( face_t &in_face );
inline int CheckFaceNormalAndLightDir ( vec3_t &in_normal );
void CalculateCrossPoint ( vec3_t &in_vertex, vec3_t &in_result );
inline void CalculateNewTexCoords ( vec3_t in_vertex [], int in_vtxIndex );
int CheckTriangleIsInsideDecal ();
int CopyVertex ( void *in_pointer );
int GetVertexSize ();
int m_maxNumVertices;
protected:
vec3_t m_origin;
matrix4x4_t *m_srcTransform;
matrix4x4_t m_invTransform;
vec3_t m_light;
vertex_t *m_vertices;
element_t *m_indices;
float m_halfLength;
shadow_vertex_t m_vtxBuffer [SHADOW_VERTEX_BUFFER_SIZE];
vec3_t m_tempBuffer [3];
int m_numVertices;
vec3_t m_normLight;
float m_minHeight;
float m_maxHeight;
vec3_t m_sunLight;
int m_triangles;
};
#endif | C++ |
#include <stdio.h>
#include "bsp.h"
#include "gth_bsp.h"
#include "d3drender.h"
#include "d3dtexturemng.h"
#include "filemng.h"
CBSP::CBSP()
{
m_subDivTolerance = 20;
m_maxPatchLevel = 4;
m_format = GTH_BSP_FORMAT;
m_shadowFormat = GTH_SHADOW_FORMAT;
VectorClear( m_camPos );
VectorClear( m_camDir );
m_frameFlag = 0;
m_shadowFrameFlag = 0;
m_visibleDist = 30000.0f;
m_removeDist = 30000.0f;
m_skyHeight = 8000.0f;
m_visData = NULL;
m_shaderMaps = NULL;
m_numBank = 0;
m_dynamicVB = NULL;
m_dynamicIB = NULL;
m_deformVB = NULL;
m_staticEB = NULL;
m_tempVB = NULL;
m_visibleQuality = GTH_WORLD_VISIBLE_QUALITY_HIGH;
}
CBSP::~CBSP()
{
GTH_SAFE_DELETE( m_dynamicVB );
GTH_SAFE_DELETE( m_dynamicIB );
GTH_SAFE_DELETE( m_shadowVB );
GTH_SAFE_DELETE( m_deformVB );
GTH_SAFE_DELETE( m_staticEB );
GTH_SAFE_DELETE( m_tempVB );
for( int i = 0 ; i < m_numBank ; i++ )
GTH_SAFE_DELETE( m_staticVB[i] );
GTH_SAFE_DELETE( m_shaderMaps );
GTH_SAFE_FREE( m_buffer );
}
void CBSP::Release()
{
int i;
m_dynamicVB->Release();
m_dynamicIB->Release();
m_shadowVB->Release();
for( i = 0 ; i < m_numBank ; i++ )
m_staticVB[i]->Release();
for( i = m_shaderType->baseDefault ; i < m_shaderType->sizeDefault ; i++ )
g_texMng.Release( m_shaderMaps[i].shader , OWNER_TYPE_BSP );
for( i = m_shaderType->baseCustom ; i < m_numShaderRefs ; i++ )
g_shaderMng.Release( m_shaderMaps[i].shader );
for( i = 0 ; i < m_numLightmaps ; i++ )
g_texMng.Release( m_lmapTexRefs[i] , OWNER_TYPE_BSP_LIGHTMAP );
}
#define lump_data(x) (m_buffer+head->lumps[(x)].offset)
#define lump_size(x) (head->lumps[(x)].size)
int CBSP::Load( char *mapName )
{
bspheader_t *head;
strcpy( m_name , mapName );
m_buffer = g_fileMng.ReadFileFromPack( mapName );
if( !m_buffer ) return false;
head = (bspheader_t *) m_buffer;
if( strcmp( head->signature , GTH_SIGNATURE ) )
{
GTH_SAFE_DELETE( m_buffer );
return false;
}
if( head->version != GTH_BSPVERSION )
{
GTH_SAFE_DELETE( m_buffer );
return false;
}
m_shaderType = &head->shaderTypeHead;
m_shaderRefs = (shaderref_t *) lump_data( GTH_SHADERREFS );
m_numShaderRefs = lump_size( GTH_SHADERREFS ) / sizeof( shaderref_t );
m_planes = (plane_t *) lump_data( GTH_PLANES );
m_numPlanes = lump_size( GTH_PLANES ) / sizeof( plane_t );
m_nodes = (node_t *) lump_data( GTH_NODES );
m_numNodes = lump_size( GTH_NODES ) / sizeof( node_t );
m_leaves = (leaf_t *) lump_data( GTH_LEAFS );
m_numLeaves = lump_size( GTH_LEAFS ) / sizeof( leaf_t );
m_faceLists = (facelist_t *) lump_data( GTH_FACELISTS );
m_numFaceLists = lump_size( GTH_FACELISTS ) / sizeof( facelist_t );
m_brushLists = (brushlist_t *) lump_data( GTH_BRUSHELISTS );
m_numBrushLists = lump_size( GTH_BRUSHELISTS ) / sizeof( brushlist_t );
m_models = (model_t *) lump_data( GTH_MODELS );
m_numModels = lump_size( GTH_MODELS ) / sizeof( model_t );
m_brushes = (brush_t *) lump_data( GTH_BRUSHES );
m_numBrushes = lump_size( GTH_BRUSHES ) / sizeof( brush_t );
m_brushSides = (brushside_t *) lump_data( GTH_BRUSHSIDES );
m_numBrushSides = lump_size( GTH_BRUSHSIDES ) / sizeof( brushside_t );
m_vertices = (vertex_t *) lump_data( GTH_VERTICES );
m_numVertices = lump_size( GTH_VERTICES ) / sizeof( vertex_t );
m_elems = (element_t *) lump_data( GTH_ELEMENTS );
m_numElems = lump_size( GTH_ELEMENTS ) / sizeof( element_t );
m_faces = (face_t *) lump_data( GTH_FACES );
m_numFaces = lump_size( GTH_FACES ) / sizeof( face_t );
m_lightmaps = (lightmap_t *) lump_data( GTH_LIGHTMAPS );
m_numLightmaps = lump_size( GTH_LIGHTMAPS ) / sizeof( lightmap_t );
m_gridLights = (gridlight_t *) lump_data( GTH_GRIDLIGHTS );
m_numGridLights = lump_size( GTH_GRIDLIGHTS ) / sizeof( gridlight_t );
m_vis = (visibility_t *) lump_data( GTH_VISIBILITY );
m_leafBaseFaces = (leafbaseface_t *) lump_data( GTH_LEAFBASEFACES );
m_gridFaceLumpHead = (gridfacelumphead_t *) lump_data( GTH_GRIDFACELUMPHEAD );
m_gridFaceLumps = (gridfacelump_t *) lump_data( GTH_GRIDFACELUMP );
m_numGridFaceLumps = lump_size( GTH_GRIDFACELUMP ) / sizeof( gridfacelump_t );
m_gridFaceLists = (gridfacelist_t *) lump_data( GTH_GRIDFACELISTS );
m_numGridFaceLists = lump_size( GTH_GRIDFACELISTS ) / sizeof( gridfacelist_t );
if( !m_shaderMaps )
{
m_shaderMaps = new shadermap_t[ m_numShaderRefs ];
if( !m_shaderMaps )
{
GTH_ERROR( GTH_ERROR_NOT_ENOUGH_MEMORY , "CBSP::Load::m_shaderMaps" );
GTH_SAFE_DELETE( m_buffer );
return false;
}
}
memset( m_shaderMaps , 0 , sizeof( shadermap_t ) * m_numShaderRefs );
return true;
}
int CBSP::Initialize( float visibleDist )
{
m_visibleDist = visibleDist;
m_visData = NULL;
if( !PrepareShaderMap() )
return false;
PrepareVertexBuffer();
if( !GenDynamicMem() )
return false;
return true;
}
int CBSP::Restore()
{
if( !PrepareShaderMap() )
return false;
for( int i = 0 ; i < m_numBank ; i++ )
{
if( m_bankSize[i] <= 0 ) continue;
m_staticVB[i]->Create(m_bankSize[ i ],
m_format,
GTH_VERTEX_BUFFER | GTH_STATIC_BUFFER | GTH_WRITEONLY );
}
m_dynamicVB->Create(MAX_SIZE_DYNAMIC_VERTEX_BUFFER,
m_format,
GTH_VERTEX_BUFFER | GTH_DYNAMIC_BUFFER | GTH_WRITEONLY);
m_dynamicIB->Create(MAX_SIZE_DYNAMIC_INDEX_BUFFER,
GTH_FORMAT_INDEX16,
GTH_INDEX_BUFFER | GTH_DYNAMIC_BUFFER | GTH_WRITEONLY );
m_shadowVB->Create(MAX_SIZE_DYNAMIC_SHADOW_VERTEX_BUFFER,
m_shadowFormat,
GTH_VERTEX_BUFFER | GTH_DYNAMIC_BUFFER | GTH_WRITEONLY);
return UploadVertexBuffer();
}
int CBSP::GenDynamicMem()
{
int i;
for( i = 0 ; i < m_numBank ; i++ )
{
if( m_bankSize[i] <= 0 ) continue;
m_staticVB[i] = new CD3DBuffer();
if( !m_staticVB[i] )
{
GTH_ERROR( GTH_ERROR_NOT_ENOUGH_MEMORY , "CBSP::GenDynamicMem::m_staticVB" );
return false;
}
m_staticVB[i]->Create(m_bankSize[i],
m_format,
GTH_VERTEX_BUFFER | GTH_STATIC_BUFFER | GTH_WRITEONLY);
}
m_dynamicVB = new CD3DBuffer();
if( !m_dynamicVB )
{
GTH_ERROR( GTH_ERROR_NOT_ENOUGH_MEMORY , "CBSP::GenDynamicMem::m_dynamicVB" );
return false;
}
m_dynamicVB->Create(MAX_SIZE_DYNAMIC_VERTEX_BUFFER,
m_format,
GTH_VERTEX_BUFFER | GTH_DYNAMIC_BUFFER | GTH_WRITEONLY);
m_dynamicIB = new CD3DBuffer();
if( !m_dynamicIB )
{
GTH_ERROR( GTH_ERROR_NOT_ENOUGH_MEMORY , "CBSP::GenDynamicMem::m_dynamicIB" );
return false;
}
m_dynamicIB->Create(MAX_SIZE_DYNAMIC_INDEX_BUFFER,
GTH_FORMAT_INDEX16,
GTH_INDEX_BUFFER | GTH_DYNAMIC_BUFFER | GTH_WRITEONLY );
m_shadowVB = new CD3DBuffer();
if( !m_shadowVB )
{
GTH_ERROR( GTH_ERROR_NOT_ENOUGH_MEMORY , "CBSP::GenDynamicMem::m_shadowVB" );
return false;
}
m_shadowVB->Create(MAX_SIZE_DYNAMIC_SHADOW_VERTEX_BUFFER,
m_shadowFormat,
GTH_VERTEX_BUFFER|GTH_DYNAMIC_BUFFER|GTH_WRITEONLY);
if( m_numDeformVerts > 0 )
{
m_deformVB = new vertex_t[ m_numDeformVerts ];
if( !m_deformVB )
{
GTH_ERROR( GTH_ERROR_NOT_ENOUGH_MEMORY , "CBSP::GenDynamicMem::m_deformVB" );
return false;
}
}
if( m_numStaticElems > 0 )
{
m_staticEB = new WORD[ m_numStaticElems ];
if( !m_staticEB )
{
GTH_ERROR( GTH_ERROR_NOT_ENOUGH_MEMORY , "CBSP::GenDynamicMem::m_staticEB" );
return false;
}
}
m_tempVB = new vertex_t[ MAX_SIZE_TEMP_VERTEX_BUFFER ];
if( !m_tempVB )
{
GTH_ERROR( GTH_ERROR_NOT_ENOUGH_MEMORY , "CBSP::GenDynamicMem::m_tempVB" );
return false;
}
return true;
}
int CBSP::PrepareShaderMap()
{
int i;
int idxShader;
char lightmap[128];
char path[128];
int len;
shader_t *shader;
for( i = m_shaderType->baseDefault ; i < m_shaderType->sizeDefault ; i++ )
{
m_shaderRefs[i].shader = -1;
m_shaderMaps[i].shader = g_texMng.Add( m_shaderRefs[i].name , OWNER_TYPE_BSP );
m_shaderMaps[i].flags = 0;
}
for( i = m_shaderType->baseCustom ; i < m_numShaderRefs ; i++ )
{
idxShader = g_shaderMng.SearchShader( m_shaderRefs[i].name );
if( idxShader < 0 )
{
GTH_ERROR( GTH_ERROR_PRINT , "Shader not founded" );
return false;
}
g_shaderMng.InitShader( idxShader );
shader = g_shaderMng.GetShader( idxShader );
m_shaderRefs[i].shader = idxShader;
m_shaderMaps[i].shader = idxShader;
m_shaderMaps[i].flags = shader->flags;
shader->shaderRefIdx = i;
}
strcpy( path , m_name );
len = strlen( path );
for( i = len - 1 ; i >= 0 ; i-- )
{
if( path[i] == '.' )
break;
}
if( i > 0 )
path[i] = 0;
for( i = 0 ; i < m_numLightmaps ; i++ )
{
sprintf( lightmap , "%s_lightmaps/LM%03d.dds" , path , i );
m_lmapTexRefs[i] = g_texMng.Add( lightmap , OWNER_TYPE_BSP_LIGHTMAP );
}
return true;
}
void CBSP::PrepareVertexBuffer()
{
shadermap_t *shaderMap;
shaderLMmap_t *LMMap;
face_t *face;
int i;
int currShader = -2;
int currLM = -2;
int prevNumStaticVerts = 0;
int currNumStaticVerts = 0;
int idxShader;
int idxLM;
int checkedSky;
int numVerts;
int numElems;
m_numDeformVerts = 0;
m_numStaticElems = 0;
m_numBank = 0;
for( i = 0 ; i < m_numFaces ; i++ )
{
face = &m_faces[i];
idxShader = face->shader;
idxLM = face->lmap;
if( currShader != idxShader )
{
shaderMap = &m_shaderMaps[ idxShader ];
currShader = idxShader;
currLM = -2;
checkedSky = false;
}
if( currLM != idxLM )
{
if( currNumStaticVerts >= MAX_BANKSIZE_VERTEXBUFFER )
{
m_bankSize[ m_numBank ] = prevNumStaticVerts;
currNumStaticVerts -= prevNumStaticVerts;
m_numBank++;
LMMap->bank = m_numBank;
}
LMMap = &shaderMap->LMMaps[ idxLM ];
LMMap->bank = m_numBank;
prevNumStaticVerts = currNumStaticVerts;
currLM = idxLM;
}
if( !( shaderMap->flags & SHADER_DEFORMVERTEXES )
&& !( shaderMap->flags & SHADER_SKY ) )
{
if( face->type != FACETYPE_PATCH )
{
currNumStaticVerts += face->vertexSize;
m_numStaticElems += face->elemSize;
}
else
{
if( !CalcPatchSize( face , &numVerts , &numElems ) )
continue;
currNumStaticVerts += numVerts;
m_numStaticElems += numElems;
}
}
else if( !( shaderMap->flags & SHADER_DEFORMVERTEXES ) && ( shaderMap->flags & SHADER_SKY ) )
{
if( !checkedSky )
{
CalcSkySize( shaderMap->flags , &numVerts , &numElems );
currNumStaticVerts += numVerts;
m_numStaticElems += numElems;
checkedSky = true;
}
}
else
{
if( shaderMap->flags & SHADER_SKY )
continue;
if( face->type != FACETYPE_PATCH )
{
m_numDeformVerts += face->vertexSize;
m_numStaticElems += face->elemSize;
}
else
{
if( !CalcPatchSize( face , &numVerts , &numElems ) )
continue;
m_numDeformVerts += numVerts;
m_numStaticElems += numElems;
}
}
}
m_bankSize[ m_numBank++ ] = currNumStaticVerts;
}
int CBSP::UploadVertexBuffer()
{
shadermap_t* shaderMap;
shaderLMmap_t* LMMap;
face_t* face;
face_t* skyFace;
vertex_t* vert;
element_t* elem;
int idxShader;
int idxLM;
int currBank = 0;
int currShader = -2;
int currLM = -2;
int currNumStaticVerts = 0;
int currNumStaticElems = 0;
int currNumDeformVerts = 0;
int checkedSky;
int elemSize;
int i;
int j;
WORD* ptrEB;
WORD* ptrStaticEB = m_staticEB;
vertex_t* ptrStaticVB = (vertex_t *) m_staticVB[0]->Lock();
vertex_t* ptrDeformVB = m_deformVB;
for( i = 0 ; i < m_numFaces ; i++ )
{
face = &m_faces[i];
idxShader = face->shader;
idxLM = face->lmap;
if( currShader != idxShader )
{
shaderMap = &m_shaderMaps[ idxShader ];
currShader = idxShader;
currLM = -2;
checkedSky = false;
skyFace = NULL;
}
if( currLM != idxLM )
{
LMMap = &shaderMap->LMMaps[ idxLM ];
if( currBank != LMMap->bank )
{
m_staticVB[ currBank ]->Unlock();
ptrStaticVB = (vertex_t *) m_staticVB[ LMMap->bank ]->Lock();
currBank = LMMap->bank;
currNumStaticVerts = 0;
}
LMMap->baseVB = currNumStaticVerts;
currLM = idxLM;
}
if( !( shaderMap->flags & SHADER_DEFORMVERTEXES ) && !( shaderMap->flags & SHADER_SKY ) )
{
if( face->type != FACETYPE_PATCH )
{
face->offsetVB = currNumStaticVerts;
face->offsetEB = currNumStaticElems;
vert = &m_vertices[ face->vertexOffset ];
memcpy( ptrStaticVB , vert , sizeof( vertex_t ) * face->vertexSize );
elem = &m_elems[ face->elemOffset ];
elemSize = face->elemSize;
ptrEB = ptrStaticEB;
for( j = 0 ; j < elemSize ; j++ , elem++ , ptrEB++ )
*ptrEB = (WORD) ( face->offsetVB + *elem );
face->sizeVB = face->vertexSize;
face->sizeEB = face->elemSize;
}
else
{
face->offsetVB = currNumStaticVerts;
face->offsetEB = currNumStaticElems;
GenPatch( face , face->offsetVB , ptrStaticVB , ptrStaticEB );
}
currNumStaticVerts += face->sizeVB;
currNumStaticElems += face->sizeEB;
ptrStaticVB += face->sizeVB;
ptrStaticEB += face->sizeEB;
LMMap->sizeVB += face->sizeVB;
}
else if( !( shaderMap->flags & SHADER_DEFORMVERTEXES ) && ( shaderMap->flags & SHADER_SKY ) )
{
if( !checkedSky )
{
face->offsetVB = currNumStaticVerts;
face->offsetEB = currNumStaticElems;
GenSky( face , face->offsetVB , shaderMap->flags , ptrStaticVB , ptrStaticEB );
currNumStaticVerts += face->sizeVB;
currNumStaticElems += face->sizeEB;
ptrStaticVB += face->sizeVB;
ptrStaticEB += face->sizeEB;
LMMap->sizeVB += face->sizeVB;
skyFace = face;
checkedSky = true;
}
else
{
face->offsetVB = skyFace->offsetVB;
face->offsetEB = skyFace->offsetEB;
face->sizeVB = skyFace->sizeVB;
face->sizeEB = skyFace->sizeEB;
}
}
else
{
if( shaderMap->flags & SHADER_SKY )
continue;
if( face->type != FACETYPE_PATCH )
{
face->offsetVB = currNumDeformVerts;
face->offsetEB = currNumStaticElems;
vert = &m_vertices[ face->vertexOffset ];
memcpy( ptrDeformVB , vert , sizeof( vertex_t ) * face->vertexSize );
elem = &m_elems[ face->elemOffset ];
elemSize = face->elemSize;
ptrEB = ptrStaticEB;
for( j = 0 ; j < elemSize ; j++ , elem++ , ptrEB++ )
*ptrEB = (WORD) *elem;
face->sizeVB = face->vertexSize;
face->sizeEB = face->elemSize;
}
else
{
face->offsetVB = currNumDeformVerts;
face->offsetEB = currNumStaticElems;
GenPatch( face , 0 , ptrDeformVB , ptrStaticEB );
}
currNumDeformVerts += face->sizeVB;
currNumStaticElems += face->sizeEB;
ptrDeformVB += face->sizeVB;
ptrStaticEB += face->sizeEB;
LMMap->sizeVB += face->sizeVB;
}
}
m_staticVB[ currBank ]->Unlock();
return true;
}
| C++ |
#pragma hdrstop
#include "d3ddevice.h"
CD3DDevice g_d3dDevice;
CD3DDevice::CD3DDevice()
{
m_pd3dDevice = NULL;
m_pBackBuffer = NULL;
m_pMainZStencilSurface = NULL;
m_VShaderVersion = VS_FFP;
}
void CD3DDevice::ActivateDevice()
{
}
void CD3DDevice::PassivateDevice()
{
if(m_pBackBuffer)
{
m_pBackBuffer->Release();
m_pBackBuffer = NULL;
}
if(m_pMainZStencilSurface)
{
m_pMainZStencilSurface->Release();
m_pMainZStencilSurface = NULL;
}
}
void CD3DDevice::ReleaseDevice()
{
m_pd3dDevice = NULL;
}
void CD3DDevice::SetD3DDevice(LPDIRECT3DDEVICE8 pd3dDevice)
{
m_pd3dDevice = pd3dDevice;
if(!m_pd3dDevice)
{
memset(&m_d3dCaps, 0, sizeof(m_d3dCaps));
m_VShaderVersion = VS_FFP;
m_pMainZStencilSurface = NULL;
return;
}
m_pd3dDevice->GetDeviceCaps(&m_d3dCaps);
DWORD vs = m_d3dCaps.VertexShaderVersion;
if( vs >= D3DVS_VERSION(3,0) )
m_VShaderVersion = VS_3_0;
else if( vs >= D3DVS_VERSION(2,0) )
m_VShaderVersion = VS_2_0;
else if( vs >= D3DVS_VERSION(1,1) )
m_VShaderVersion = VS_1_1;
else
m_VShaderVersion = VS_FFP;
DWORD dwCaps = m_d3dCaps.RasterCaps;
if((dwCaps & D3DPRASTERCAPS_FOGTABLE ) && ( dwCaps & D3DPRASTERCAPS_ZFOG ))
{
m_FogType = GTH_PIXEL_FOG_TYPE;
}
else if( dwCaps & D3DPRASTERCAPS_FOGVERTEX )
{
m_FogType = GTH_VERTEX_FOG_TYPE;
}
else
{
m_FogType = GTH_NULL_FOG_TYPE;
}
}
| C++ |
#ifndef _FRUSTUM_H
#define _FRUSTUM_H
#include "gth_bsp.h"
#define FRUSTUM_NEAR_PLAIN 0
#define FRUSTUM_LEFT_PLAIN 1
#define FRUSTUM_RIGHT_PLAIN 2
#define FRUSTUM_TOP_PLAIN 3
#define FRUSTUM_BOTTOM_PLAIN 4
typedef struct
{
int X;
int Y;
int Width;
int Height;
float MinZ;
float MaxZ;
} viewport_t;
typedef struct
{
float fov;
float aspect;
float znear;
float zfar;
viewport_t viewport;
} projectionparam_t;
class CFrustum
{
public:
CFrustum() {};
~CFrustum() {};
plane_t planes[5];
void Setup( vec3_t angles , vec3_t position , projectionparam_t *projectParm );
int Cull( vec3_t mins , vec3_t maxs );
int Cull_Exact( vec3_t mins , vec3_t maxs );
};
#endif | C++ |
#include "core_def.h"
#include "d3drender.h"
#include "d3dbuffer.h"
#include "d3ddevice.h"
#include "d3dtexturemng.h"
CD3DRender g_d3dRender;
CD3DRender::CD3DRender()
{
m_bFog = false;
}
CD3DRender::~CD3DRender()
{
}
void CD3DRender::InitDevice()
{
SetDefaultRenderstates();
}
void CD3DRender::SetTransform( D3DTRANSFORMSTATETYPE transType , matrix4x4_t *matrix )
{
g_d3dDevice.GetD3DDevice()->SetTransform( transType, (D3DMATRIX *) matrix );
}
void CD3DRender::SetStreamSource( int numStream , LPDIRECT3DVERTEXBUFFER8 ptrVB , int sizeStride )
{
g_d3dDevice.GetD3DDevice()->SetStreamSource( numStream , ptrVB , sizeStride );
}
void CD3DRender::SetIndices( LPDIRECT3DINDEXBUFFER8 ptrIB , int baseVertexIdx )
{
g_d3dDevice.GetD3DDevice()->SetIndices( ptrIB , baseVertexIdx );
}
void CD3DRender::SetTexture( int stage , LPDIRECT3DTEXTURE8 d3dTex )
{
g_d3dDevice.GetD3DDevice()->SetTexture( stage , d3dTex );
}
void CD3DRender::SetLight( int idxLight , light_t *light )
{
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
pd3dDevice->SetLight ( idxLight , (D3DLIGHT8*) light );
pd3dDevice->LightEnable ( idxLight , TRUE );
pd3dDevice->SetRenderState ( D3DRS_AMBIENT, 0xFF808080 );
}
void CD3DRender::SetMaterial( material_t *material )
{
g_d3dDevice.GetD3DDevice()->SetMaterial ( (D3DMATERIAL8*) material );
}
void CD3DRender::SetupVertexFog(DWORD color, float start, float end, DWORD mode, int useRange, float density)
{
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
pd3dDevice->SetRenderState( D3DRS_FOGCOLOR , m_FogColor );
pd3dDevice->SetRenderState( D3DRS_FOGTABLEMODE , D3DFOG_NONE );
if( D3DFOG_LINEAR == mode )
{
pd3dDevice->SetRenderState( D3DRS_FOGVERTEXMODE , mode );
pd3dDevice->SetRenderState( D3DRS_FOGSTART , *(DWORD *)(&start) );
pd3dDevice->SetRenderState( D3DRS_FOGEND , *(DWORD *)(&end) );
}
else
{
pd3dDevice->SetRenderState( D3DRS_FOGVERTEXMODE , mode );
pd3dDevice->SetRenderState( D3DRS_FOGDENSITY , *(DWORD *)(&density) );
}
if( useRange )
pd3dDevice->SetRenderState( D3DRS_RANGEFOGENABLE , TRUE );
}
void CD3DRender::SetupPixelFog(DWORD color, float start, float end, DWORD mode, float density)
{
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
pd3dDevice->SetRenderState( D3DRS_FOGCOLOR , color );
pd3dDevice->SetRenderState( D3DRS_FOGVERTEXMODE , D3DFOG_NONE );
if( D3DFOG_LINEAR == mode )
{
pd3dDevice->SetRenderState( D3DRS_FOGTABLEMODE , mode );
pd3dDevice->SetRenderState( D3DRS_FOGSTART , *(DWORD *)(&start) );
pd3dDevice->SetRenderState( D3DRS_FOGEND , *(DWORD *)(&end) );
}
else
{
pd3dDevice->SetRenderState( D3DRS_FOGTABLEMODE , mode );
pd3dDevice->SetRenderState( D3DRS_FOGDENSITY , *(DWORD *)(&density) );
}
}
void CD3DRender::SetSkyFogParameter(DWORD color , float start , float end)
{
if(g_d3dDevice.GetFogType() == GTH_PIXEL_FOG_TYPE)
SetupPixelFog(color, start, end);
else if(g_d3dDevice.GetFogType() == GTH_VERTEX_FOG_TYPE)
SetupVertexFog(color, start, end);
}
void CD3DRender::SetFogParameter(DWORD color , float start , float end)
{
m_FogColor = color;
m_FogStart = start;
m_FogEnd = end;
if(g_d3dDevice.GetFogType() == GTH_PIXEL_FOG_TYPE)
SetupPixelFog(color, start, end);
else if(g_d3dDevice.GetFogType() == GTH_VERTEX_FOG_TYPE)
SetupVertexFog(color, start, end);
}
void CD3DRender::SetFogEnable()
{
if(g_d3dDevice.GetFogType())
{
m_bFog = true;
g_d3dDevice.GetD3DDevice()->SetRenderState( D3DRS_FOGENABLE , true );
}
else
{
m_bFog = false;
g_d3dDevice.GetD3DDevice()->SetRenderState( D3DRS_FOGENABLE, false );
}
}
void CD3DRender::SetFogDisable()
{
m_bFog = false;
g_d3dDevice.GetD3DDevice()->SetRenderState( D3DRS_FOGENABLE, false );
}
void CD3DRender::SetVertexShader( DWORD format )
{
if( format & GTH_FORMAT_XYZ )
m_format = D3DFVF_XYZ;
else if( format & GTH_FORMAT_XYZRHW )
m_format = D3DFVF_XYZRHW;
if( format & GTH_FORMAT_NORMAL )
m_format |= D3DFVF_NORMAL;
if( format & GTH_FORMAT_DIFFUSE )
m_format |= D3DFVF_DIFFUSE;
if( format & GTH_FORMAT_SPECULAR )
m_format |= D3DFVF_SPECULAR;
if( format & GTH_FORMAT_TEXVERTEXFLAG )
{
switch( (format & ~GTH_FORMAT_TEXVERTEXFLAG ) >> 8 )
{
case 0:
m_format |= D3DFVF_TEX0;
break;
case 1:
m_format |= D3DFVF_TEX1;
break;
case 2:
m_format |= D3DFVF_TEX2;
break;
case 3:
m_format |= D3DFVF_TEX3;
break;
case 4:
m_format |= D3DFVF_TEX4;
break;
case 5:
m_format |= D3DFVF_TEX5;
break;
case 6:
m_format |= D3DFVF_TEX6;
break;
case 7:
m_format |= D3DFVF_TEX7;
break;
case 8:
m_format |= D3DFVF_TEX8;
break;
default:
GTH_ERROR( GTH_ERROR_PRINT , "vertex buffer couldn't have more than 8 texture coord" );
break;
}
}
g_d3dDevice.GetD3DDevice()->SetVertexShader( m_format );
}
void CD3DRender::SetDefaultRenderState()
{
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
pd3dDevice->SetRenderState( D3DRS_LIGHTING , FALSE );
pd3dDevice->SetRenderState( D3DRS_CULLMODE , D3DCULL_CCW );
pd3dDevice->SetRenderState( D3DRS_DITHERENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_SPECULARENABLE , FALSE );
pd3dDevice->SetRenderState( D3DRS_ZENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_ZBIAS , 0 );
pd3dDevice->SetRenderState( D3DRS_ZFUNC , D3DCMP_LESSEQUAL );
pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , FALSE );
pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE , FALSE );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS , D3DTTFF_DISABLE );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSU , D3DTADDRESS_WRAP );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSV , D3DTADDRESS_WRAP );
pd3dDevice->SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP , D3DTOP_SELECTARG1 );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1 , D3DTA_TEXTURE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2 , D3DTA_DIFFUSE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP , D3DTOP_SELECTARG1 );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1 , D3DTA_TEXTURE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG2 , D3DTA_DIFFUSE );
pd3dDevice->SetTextureStageState( 1, D3DTSS_TEXCOORDINDEX, 1 );
pd3dDevice->SetTextureStageState( 1, D3DTSS_COLOROP , D3DTOP_MODULATE );
pd3dDevice->SetTextureStageState( 1, D3DTSS_COLORARG1 , D3DTA_TEXTURE );
pd3dDevice->SetTextureStageState( 1, D3DTSS_COLORARG2 , D3DTA_CURRENT );
pd3dDevice->SetTextureStageState( 1, D3DTSS_ALPHAOP , D3DTOP_DISABLE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_MINFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 0, D3DTSS_MAGFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 1, D3DTSS_MINFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 1, D3DTSS_MAGFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 0, D3DTSS_MIPFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 1, D3DTSS_MIPFILTER , D3DTEXF_LINEAR );
}
void CD3DRender::ApplyDiffuseRenderState()
{
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP , D3DTOP_MODULATE );
pd3dDevice->SetTextureStageState( 1, D3DTSS_COLOROP , D3DTOP_DISABLE );
}
void CD3DRender::ReleaseDiffuseRenderState()
{
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP , D3DTOP_SELECTARG1 );
pd3dDevice->SetTextureStageState( 1, D3DTSS_COLOROP , D3DTOP_MODULATE );
}
void CD3DRender::SetCustomRenderState()
{
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
pd3dDevice->SetRenderState( D3DRS_LIGHTING , FALSE );
pd3dDevice->SetRenderState( D3DRS_CULLMODE , D3DCULL_CCW );
pd3dDevice->SetRenderState( D3DRS_DITHERENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_SPECULARENABLE , FALSE );
pd3dDevice->SetRenderState( D3DRS_ZENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_ZBIAS , 0 );
pd3dDevice->SetRenderState( D3DRS_ZFUNC , D3DCMP_LESSEQUAL );
pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , FALSE );
pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE , FALSE );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS , D3DTTFF_DISABLE );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSU , D3DTADDRESS_WRAP );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSV , D3DTADDRESS_WRAP );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP , D3DTOP_SELECTARG1 );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1 , D3DTA_TEXTURE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2 , D3DTA_DIFFUSE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP , D3DTOP_SELECTARG1 );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1 , D3DTA_TEXTURE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG2 , D3DTA_DIFFUSE );
pd3dDevice->SetTextureStageState( 1, D3DTSS_COLOROP , D3DTOP_DISABLE );
pd3dDevice->SetTextureStageState( 1, D3DTSS_ALPHAOP , D3DTOP_DISABLE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_MINFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 0, D3DTSS_MAGFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 1, D3DTSS_MINFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 1, D3DTSS_MAGFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 0, D3DTSS_MIPFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 1, D3DTSS_MIPFILTER , D3DTEXF_LINEAR );
}
void CD3DRender::SetMDLRenderState()
{
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
pd3dDevice->SetRenderState( D3DRS_LIGHTING , TRUE );
pd3dDevice->SetRenderState( D3DRS_CULLMODE , D3DCULL_CCW );
pd3dDevice->SetRenderState( D3DRS_DITHERENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_SPECULARENABLE , FALSE );
pd3dDevice->SetRenderState( D3DRS_ZENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_ZBIAS , 0 );
pd3dDevice->SetRenderState( D3DRS_ZFUNC , D3DCMP_LESSEQUAL );
pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , FALSE );
pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE , FALSE );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS , D3DTTFF_DISABLE );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSU , D3DTADDRESS_WRAP );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSV , D3DTADDRESS_WRAP );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP , D3DTOP_MODULATE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1 , D3DTA_TEXTURE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2 , D3DTA_DIFFUSE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP , D3DTOP_SELECTARG1 );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1 , D3DTA_TEXTURE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG2 , D3DTA_DIFFUSE );
pd3dDevice->SetTextureStageState( 1, D3DTSS_COLOROP , D3DTOP_DISABLE );
pd3dDevice->SetTextureStageState( 1, D3DTSS_ALPHAOP , D3DTOP_DISABLE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_MINFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 0, D3DTSS_MAGFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 1, D3DTSS_MINFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 1, D3DTSS_MAGFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 0, D3DTSS_MIPFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 1, D3DTSS_MIPFILTER , D3DTEXF_LINEAR );
}
void CD3DRender::SetCharacterRenderState()
{
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
pd3dDevice->SetRenderState( D3DRS_LIGHTING , TRUE );
pd3dDevice->SetRenderState( D3DRS_CULLMODE , D3DCULL_CCW );
pd3dDevice->SetRenderState( D3DRS_DITHERENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_SPECULARENABLE , FALSE );
pd3dDevice->SetRenderState( D3DRS_ZENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_ZBIAS , 0 );
pd3dDevice->SetRenderState( D3DRS_ZFUNC , D3DCMP_LESSEQUAL );
pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , FALSE );
pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE , FALSE );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS , D3DTTFF_DISABLE );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSU , D3DTADDRESS_WRAP );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSV , D3DTADDRESS_WRAP );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP , D3DTOP_MODULATE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1 , D3DTA_TEXTURE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2 , D3DTA_DIFFUSE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP , D3DTOP_SELECTARG1 );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1 , D3DTA_TEXTURE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG2 , D3DTA_DIFFUSE );
pd3dDevice->SetTextureStageState( 1, D3DTSS_COLOROP , D3DTOP_DISABLE );
pd3dDevice->SetTextureStageState( 1, D3DTSS_ALPHAOP , D3DTOP_DISABLE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_MINFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 0, D3DTSS_MAGFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 1, D3DTSS_MINFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 1, D3DTSS_MAGFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 0, D3DTSS_MIPFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 1, D3DTSS_MIPFILTER , D3DTEXF_LINEAR );
}
void CD3DRender::SetShadowRenderState()
{
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
pd3dDevice->SetRenderState( D3DRS_LIGHTING , TRUE );
pd3dDevice->SetRenderState( D3DRS_CULLMODE , D3DCULL_CCW );
pd3dDevice->SetRenderState( D3DRS_DITHERENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_SPECULARENABLE , FALSE );
pd3dDevice->SetRenderState( D3DRS_ZENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_ZBIAS , 0 );
pd3dDevice->SetRenderState( D3DRS_ZFUNC , D3DCMP_LESSEQUAL );
pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , FALSE );
pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE , FALSE );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS , D3DTTFF_DISABLE );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSU , D3DTADDRESS_CLAMP );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSV , D3DTADDRESS_CLAMP );
pd3dDevice->SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 );
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_MODULATE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1 , D3DTA_TEXTURE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG2 , D3DTA_CURRENT );
pd3dDevice->SetTextureStageState( 1, D3DTSS_COLOROP , D3DTOP_DISABLE );
pd3dDevice->SetTextureStageState( 1, D3DTSS_ALPHAOP , D3DTOP_DISABLE );
pd3dDevice->SetTextureStageState( 0, D3DTSS_MINFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 0, D3DTSS_MAGFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 1, D3DTSS_MINFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 1, D3DTSS_MAGFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 0, D3DTSS_MIPFILTER , D3DTEXF_LINEAR );
pd3dDevice->SetTextureStageState( 1, D3DTSS_MIPFILTER , D3DTEXF_LINEAR );
}
void CD3DRender::RenderDefault( int baseVB , int sizeVB , int baseIB , int sizeRenderElems )
{
g_d3dDevice.GetD3DDevice()->DrawIndexedPrimitive( D3DPT_TRIANGLELIST , baseVB , sizeVB , baseIB , sizeRenderElems / 3 );
}
void CD3DRender::RenderTransDefault( int baseVB , int sizeVB , int baseIB , int sizeRenderElems , DWORD color )
{
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
pd3dDevice->SetRenderState( D3DRS_TEXTUREFACTOR , color );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLORARG2 , D3DTA_TFACTOR );
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_SRCBLEND , D3DBLEND_SRCCOLOR );
pd3dDevice->SetRenderState( D3DRS_DESTBLEND , D3DBLEND_INVSRCCOLOR );
pd3dDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST , baseVB , sizeVB , baseIB , sizeRenderElems / 3 );
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , FALSE );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLORARG2 , D3DTA_DIFFUSE );
}
void CD3DRender::RenderCustom( shader_t *shader , int baseVB , int sizeVB , int baseIB , int sizeRenderElems )
{
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
shaderpass_t *pass;
DWORD flags;
if( shader->flags & SHADER_CULL )
{
if( shader->flags & SHADER_CULL_NONE )
pd3dDevice->SetRenderState( D3DRS_CULLMODE , D3DCULL_NONE );
else if( shader->flags & SHADER_CULL_FRONT )
pd3dDevice->SetRenderState( D3DRS_CULLMODE , D3DCULL_CW );
}
pass = &shader->passes[0];
for( int i = 0 ; i < shader->numPasses ; i++ , pass++ )
{
flags = pass->flags;
if( flags & SHADERPASS_MAP_LIGHTMAP )
{
pd3dDevice->SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 1 );
}
else
{
pd3dDevice->SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 );
}
pd3dDevice->SetTexture( 0 , g_texMng.GetD3DTexture( pass->texRef ) );
if( flags & SHADERPASS_CLAMPMAP )
{
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSU , D3DTADDRESS_CLAMP );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSV , D3DTADDRESS_CLAMP );
}
if( flags & SHADERPASS_BLEND )
{
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_SRCBLEND , pass->blend.src );
pd3dDevice->SetRenderState( D3DRS_DESTBLEND , pass->blend.dest );
}
if( flags & SHADERPASS_RGBGEN )
{
pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLOROP , D3DTOP_MODULATE );
if( !( pass->rgbGen.type & SHADERPASS_RGBGEN_VERTEX ) )
{
pd3dDevice->SetRenderState( D3DRS_TEXTUREFACTOR , pass->rgbGen.color );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLORARG2 , D3DTA_TFACTOR );
}
}
if( flags & SHADERPASS_ALPHAGEN )
{
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAOP , D3DTOP_SELECTARG2 );
if( !( pass->alphaGen.type & SHADERPASS_RGBGEN_VERTEX ) )
{
pd3dDevice->SetRenderState( D3DRS_TEXTUREFACTOR , pass->alphaGen.color );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAARG2 , D3DTA_TFACTOR );
}
}
if( flags & SHADERPASS_DEPTHFUNC )
pd3dDevice->SetRenderState( D3DRS_ZFUNC , pass->depthFunc );
if( flags & SHADERPASS_ALPHAFUNC )
{
pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_ALPHAFUNC , pass->alphaFunc.func );
pd3dDevice->SetRenderState( D3DRS_ALPHAREF , pass->alphaFunc.ref );
}
if( flags & SHADERPASS_NONDEPTHWRITE )
pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE , FALSE );
if( flags & SHADERPASS_TCMOD )
{
pd3dDevice->SetTransform( D3DTS_TEXTURE0, (D3DMATRIX *)&pass->tcMod.tcMatrix );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS , D3DTTFF_COUNT2 );
}
if( flags & SHADERPASS_TCGEN )
{
pd3dDevice->SetTransform( D3DTS_TEXTURE0, (D3DMATRIX *)&shader->tcGenMatrix );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS , D3DTTFF_COUNT2 );
}
pd3dDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST , baseVB , sizeVB , baseIB , sizeRenderElems / 3 );
if( flags & SHADERPASS_CLAMPMAP )
{
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSU , D3DTADDRESS_WRAP );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSV , D3DTADDRESS_WRAP );
}
if( flags & SHADERPASS_BLEND )
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , FALSE );
if( flags & SHADERPASS_RGBGEN )
{
pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLOROP , D3DTOP_SELECTARG1 );
if( !( pass->rgbGen.type & SHADERPASS_RGBGEN_VERTEX ) )
pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLORARG2 , D3DTA_DIFFUSE );
}
if( flags & SHADERPASS_ALPHAGEN )
{
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAOP , D3DTOP_SELECTARG1 );
if( !( pass->alphaGen.type & SHADERPASS_RGBGEN_VERTEX ) )
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAARG2 , D3DTA_DIFFUSE );
}
if( flags & SHADERPASS_DEPTHFUNC )
pd3dDevice->SetRenderState( D3DRS_ZFUNC , D3DCMP_LESSEQUAL );
if( flags & SHADERPASS_ALPHAFUNC )
pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE , FALSE );
if( flags & SHADERPASS_NONDEPTHWRITE )
pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE , TRUE );
if( flags & SHADERPASS_TCMOD || flags & SHADERPASS_TCGEN )
pd3dDevice->SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS , D3DTTFF_DISABLE );
}
if( shader->flags & SHADER_CULL )
pd3dDevice->SetRenderState( D3DRS_CULLMODE , D3DCULL_CCW );
}
void CD3DRender::RenderSky( shader_t *shader , int baseVB , int sizeVB , int baseIB , int sizeRenderElems )
{
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
shaderpass_t *pass;
DWORD flags;
if( shader->flags & SHADER_CULL )
{
if( shader->flags & SHADER_CULL_NONE )
pd3dDevice->SetRenderState( D3DRS_CULLMODE , D3DCULL_NONE );
else if( shader->flags & SHADER_CULL_FRONT )
pd3dDevice->SetRenderState( D3DRS_CULLMODE , D3DCULL_CW );
}
pass = &shader->passes[0];
for( int i = 0 ; i < shader->numPasses ; i++ , pass++ )
{
flags = pass->flags;
pd3dDevice->SetTexture( 0 , g_texMng.GetD3DTexture( pass->texRef ) );
if( flags & SHADERPASS_CLAMPMAP )
{
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSU , D3DTADDRESS_CLAMP );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSV , D3DTADDRESS_CLAMP );
}
switch( i )
{
case 0:
{
pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE , false);
pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP , D3DTOP_SELECTARG1);
pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
}
break;
case 1:
{
if(shader->numPasses == 2)
{
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_SRCBLEND , D3DBLEND_SRCCOLOR );
pd3dDevice->SetRenderState( D3DRS_DESTBLEND , D3DBLEND_INVSRCCOLOR );
pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP , D3DTOP_SELECTARG1);
pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
}
else
{
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_SRCBLEND , D3DBLEND_SRCCOLOR );
pd3dDevice->SetRenderState( D3DRS_DESTBLEND , D3DBLEND_ONE );
pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP , D3DTOP_SELECTARG1);
pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
}
}
break;
case 2:
{
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_SRCBLEND , D3DBLEND_SRCCOLOR );
pd3dDevice->SetRenderState( D3DRS_DESTBLEND , D3DBLEND_INVSRCCOLOR );
pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP , D3DTOP_SELECTARG1);
pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
}
break;
}
if( flags & SHADERPASS_TCMOD )
{
pd3dDevice->SetTransform( D3DTS_TEXTURE0, (D3DMATRIX *)&pass->tcMod.tcMatrix );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS , D3DTTFF_COUNT2 );
}
if( flags & SHADERPASS_TCGEN )
{
pd3dDevice->SetTransform( D3DTS_TEXTURE0, (D3DMATRIX *)&shader->tcGenMatrix );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS , D3DTTFF_COUNT2 );
}
pd3dDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST , baseVB , sizeVB , baseIB , sizeRenderElems / 3 );
if( flags & SHADERPASS_CLAMPMAP )
{
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSU , D3DTADDRESS_WRAP );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSV , D3DTADDRESS_WRAP );
}
if( flags & SHADERPASS_BLEND )
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , FALSE );
if( flags & SHADERPASS_RGBGEN )
{
pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLOROP , D3DTOP_SELECTARG1 );
if( !( pass->rgbGen.type & SHADERPASS_RGBGEN_VERTEX ) )
pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLORARG2 , D3DTA_DIFFUSE );
}
if( flags & SHADERPASS_ALPHAGEN )
{
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAOP , D3DTOP_SELECTARG1 );
if( !( pass->alphaGen.type & SHADERPASS_RGBGEN_VERTEX ) )
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAARG2 , D3DTA_DIFFUSE );
}
if( flags & SHADERPASS_DEPTHFUNC )
pd3dDevice->SetRenderState( D3DRS_ZFUNC , D3DCMP_LESSEQUAL );
if( flags & SHADERPASS_ALPHAFUNC )
pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE , FALSE );
if( flags & SHADERPASS_NONDEPTHWRITE )
pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE , TRUE );
if( flags & SHADERPASS_TCMOD || flags & SHADERPASS_TCGEN )
pd3dDevice->SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS , D3DTTFF_DISABLE );
}
if( shader->flags & SHADER_CULL )
pd3dDevice->SetRenderState( D3DRS_CULLMODE , D3DCULL_CCW );
}
void CD3DRender::RenderMDLCustom( shader_t *shader , int baseVB , int sizeVB , int baseIB , int sizeRenderElems )
{
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
shaderpass_t *pass;
DWORD flags;
if( shader->flags & SHADER_CULL )
{
if( shader->flags & SHADER_CULL_NONE )
pd3dDevice->SetRenderState( D3DRS_CULLMODE , D3DCULL_NONE );
else if( shader->flags & SHADER_CULL_FRONT )
pd3dDevice->SetRenderState( D3DRS_CULLMODE , D3DCULL_CW );
}
pass = &shader->passes[0];
for( int i = 0 ; i < shader->numPasses ; i++ , pass++ )
{
flags = pass->flags;
if( flags & SHADERPASS_MAP_LIGHTMAP )
{
pd3dDevice->SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 1 );
}
else
{
pd3dDevice->SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 );
}
pd3dDevice->SetTexture( 0 , g_texMng.GetD3DTexture( pass->texRef ) );
if( flags & SHADERPASS_CLAMPMAP )
{
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSU , D3DTADDRESS_CLAMP );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSV , D3DTADDRESS_CLAMP );
}
if( flags & SHADERPASS_BLEND )
{
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_SRCBLEND , pass->blend.src );
pd3dDevice->SetRenderState( D3DRS_DESTBLEND , pass->blend.dest );
}
if( flags & SHADERPASS_RGBGEN )
{
if( !( pass->rgbGen.type & SHADERPASS_RGBGEN_VERTEX ) )
{
pd3dDevice->SetRenderState( D3DRS_TEXTUREFACTOR , pass->rgbGen.color );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLORARG2 , D3DTA_TFACTOR );
}
}
if( flags & SHADERPASS_ALPHAGEN )
{
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAOP , D3DTOP_SELECTARG2 );
if( !( pass->alphaGen.type & SHADERPASS_RGBGEN_VERTEX ) )
{
pd3dDevice->SetRenderState( D3DRS_TEXTUREFACTOR , pass->alphaGen.color );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAARG2 , D3DTA_TFACTOR );
}
}
if( flags & SHADERPASS_DEPTHFUNC )
pd3dDevice->SetRenderState( D3DRS_ZFUNC , pass->depthFunc );
if( flags & SHADERPASS_ALPHAFUNC )
{
pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_ALPHAFUNC , pass->alphaFunc.func );
pd3dDevice->SetRenderState( D3DRS_ALPHAREF , pass->alphaFunc.ref );
}
if( flags & SHADERPASS_NONDEPTHWRITE )
pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE , FALSE );
if( flags & SHADERPASS_TCMOD )
{
pd3dDevice->SetTransform( D3DTS_TEXTURE0, (D3DMATRIX *)&pass->tcMod.tcMatrix );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS , D3DTTFF_COUNT2 );
}
if( flags & SHADERPASS_TCGEN )
{
pd3dDevice->SetTransform( D3DTS_TEXTURE0, (D3DMATRIX *)&shader->tcGenMatrix );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS , D3DTTFF_COUNT2 );
}
pd3dDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST , baseVB , sizeVB , baseIB , sizeRenderElems / 3 );
if( flags & SHADERPASS_CLAMPMAP )
{
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSU , D3DTADDRESS_WRAP );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSV , D3DTADDRESS_WRAP );
}
if( flags & SHADERPASS_BLEND )
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , FALSE );
if( flags & SHADERPASS_RGBGEN )
{
if( !( pass->rgbGen.type & SHADERPASS_RGBGEN_VERTEX ) )
pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLORARG2 , D3DTA_DIFFUSE );
}
if( flags & SHADERPASS_ALPHAGEN )
{
if( !( pass->alphaGen.type & SHADERPASS_RGBGEN_VERTEX ) )
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAARG2 , D3DTA_DIFFUSE );
}
if( flags & SHADERPASS_DEPTHFUNC )
pd3dDevice->SetRenderState( D3DRS_ZFUNC , D3DCMP_LESSEQUAL );
if( flags & SHADERPASS_ALPHAFUNC )
pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE , FALSE );
if( flags & SHADERPASS_NONDEPTHWRITE )
pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE , TRUE );
if( flags & SHADERPASS_TCMOD || flags & SHADERPASS_TCGEN )
pd3dDevice->SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS , D3DTTFF_DISABLE );
}
if( shader->flags & SHADER_CULL )
pd3dDevice->SetRenderState( D3DRS_CULLMODE , D3DCULL_CCW );
}
void CD3DRender::RenderTransMDLCustom( shader_t *shader , int baseVB , int sizeVB , int baseIB , int sizeRenderElems , DWORD color )
{
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
shaderpass_t *pass;
DWORD flags;
if( shader->flags & SHADER_CULL )
{
if( shader->flags & SHADER_CULL_NONE )
pd3dDevice->SetRenderState( D3DRS_CULLMODE , D3DCULL_NONE );
else if( shader->flags & SHADER_CULL_FRONT )
pd3dDevice->SetRenderState( D3DRS_CULLMODE , D3DCULL_CW );
}
pd3dDevice->SetRenderState( D3DRS_TEXTUREFACTOR , color );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLORARG2 , D3DTA_TFACTOR );
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_SRCBLEND , D3DBLEND_SRCCOLOR );
pd3dDevice->SetRenderState( D3DRS_DESTBLEND , D3DBLEND_INVSRCCOLOR );
pass = &shader->passes[0];
for( int i = 0 ; i < shader->numPasses ; i++ , pass++ )
{
flags = pass->flags;
if( flags & SHADERPASS_MAP_LIGHTMAP )
{
pd3dDevice->SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 1 );
}
else
{
pd3dDevice->SetTextureStageState( 0, D3DTSS_TEXCOORDINDEX, 0 );
}
pd3dDevice->SetTexture( 0 , g_texMng.GetD3DTexture( pass->texRef ) );
if( flags & SHADERPASS_CLAMPMAP )
{
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSU , D3DTADDRESS_CLAMP );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSV , D3DTADDRESS_CLAMP );
}
if( flags & SHADERPASS_DEPTHFUNC )
pd3dDevice->SetRenderState( D3DRS_ZFUNC , pass->depthFunc );
if( flags & SHADERPASS_ALPHAFUNC )
{
pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_ALPHAFUNC , pass->alphaFunc.func );
pd3dDevice->SetRenderState( D3DRS_ALPHAREF , pass->alphaFunc.ref );
}
if( flags & SHADERPASS_NONDEPTHWRITE )
pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE , FALSE );
if( flags & SHADERPASS_TCMOD )
{
pd3dDevice->SetTransform( D3DTS_TEXTURE0, (D3DMATRIX *)&pass->tcMod.tcMatrix );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS , D3DTTFF_COUNT2 );
}
if( flags & SHADERPASS_TCGEN )
{
pd3dDevice->SetTransform( D3DTS_TEXTURE0, (D3DMATRIX *)&shader->tcGenMatrix );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS , D3DTTFF_COUNT2 );
}
pd3dDevice->DrawIndexedPrimitive( D3DPT_TRIANGLELIST , baseVB , sizeVB , baseIB , sizeRenderElems / 3 );
if( flags & SHADERPASS_CLAMPMAP )
{
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSU , D3DTADDRESS_WRAP );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ADDRESSV , D3DTADDRESS_WRAP );
}
if( flags & SHADERPASS_DEPTHFUNC )
pd3dDevice->SetRenderState( D3DRS_ZFUNC , D3DCMP_LESSEQUAL );
if( flags & SHADERPASS_ALPHAFUNC )
pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE , FALSE );
if( flags & SHADERPASS_NONDEPTHWRITE )
pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE , TRUE );
if( flags & SHADERPASS_TCMOD || flags & SHADERPASS_TCGEN )
pd3dDevice->SetTextureStageState( 0 , D3DTSS_TEXTURETRANSFORMFLAGS , D3DTTFF_DISABLE );
}
if( shader->flags & SHADER_CULL )
pd3dDevice->SetRenderState( D3DRS_CULLMODE , D3DCULL_CCW );
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , FALSE );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLORARG2 , D3DTA_DIFFUSE );
}
void CD3DRender::SetAttachShader( DWORD color )
{
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
pd3dDevice->SetTextureStageState( 0 , D3DTSS_TEXCOORDINDEX, 0 );
pd3dDevice->SetTexture( 0 , g_texMng.GetD3DTexture( g_texMng.GetWhiteImageRef() ) );
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , TRUE );
pd3dDevice->SetRenderState( D3DRS_SRCBLEND , D3DBLEND_SRCALPHA );
pd3dDevice->SetRenderState( D3DRS_DESTBLEND , D3DBLEND_INVSRCALPHA );
pd3dDevice->SetRenderState( D3DRS_TEXTUREFACTOR , color );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLOROP , D3DTOP_SELECTARG2 );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLORARG2 , D3DTA_TFACTOR );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAOP , D3DTOP_SELECTARG2 );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAARG2 , D3DTA_TFACTOR );
}
void CD3DRender::EndAttachShader()
{
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE , FALSE );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLOROP , D3DTOP_SELECTARG1 );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_COLORARG2 , D3DTA_DIFFUSE );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAOP , D3DTOP_SELECTARG1 );
pd3dDevice->SetTextureStageState( 0 , D3DTSS_ALPHAARG2 , D3DTA_DIFFUSE );
}
void CD3DRender::SetDefaultRenderstates()
{
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
pd3dDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
pd3dDevice->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
pd3dDevice->SetRenderState(D3DRS_FOGENABLE, FALSE);
pd3dDevice->SetRenderState(D3DRS_FOGCOLOR, 0xFF0000);
pd3dDevice->SetRenderState(D3DRS_FOGTABLEMODE, D3DFOG_NONE );
pd3dDevice->SetRenderState(D3DRS_FOGVERTEXMODE, D3DFOG_LINEAR );
pd3dDevice->SetRenderState(D3DRS_RANGEFOGENABLE, FALSE );
pd3dDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
pd3dDevice->SetRenderState(D3DRS_ZFUNC,D3DCMP_LESSEQUAL);
pd3dDevice->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
pd3dDevice->SetRenderState(D3DRS_DITHERENABLE, TRUE);
pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
pd3dDevice->SetRenderState(D3DRS_STENCILENABLE, FALSE);
pd3dDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
pd3dDevice->SetRenderState(D3DRS_CLIPPING, TRUE);
pd3dDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
pd3dDevice->SetRenderState(D3DRS_SPECULARENABLE, FALSE);
pd3dDevice->SetRenderState(D3DRS_COLORVERTEX, FALSE);
pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_DISABLE);
pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
pd3dDevice->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);
pd3dDevice->SetTextureStageState(1, D3DTSS_COLORARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(1, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
pd3dDevice->SetTextureStageState(1, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
pd3dDevice->SetTextureStageState(1, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(1, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
pd3dDevice->SetTextureStageState(2, D3DTSS_COLOROP, D3DTOP_DISABLE);
pd3dDevice->SetTextureStageState(2, D3DTSS_COLORARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(2, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
pd3dDevice->SetTextureStageState(2, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
pd3dDevice->SetTextureStageState(2, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(2, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
pd3dDevice->SetTextureStageState(3, D3DTSS_COLOROP, D3DTOP_DISABLE);
pd3dDevice->SetTextureStageState(3, D3DTSS_COLORARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(3, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
pd3dDevice->SetTextureStageState(3, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
pd3dDevice->SetTextureStageState(3, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(3, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
pd3dDevice->SetTextureStageState(4, D3DTSS_COLOROP, D3DTOP_DISABLE);
pd3dDevice->SetTextureStageState(4, D3DTSS_COLORARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(4, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
pd3dDevice->SetTextureStageState(4, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
pd3dDevice->SetTextureStageState(4, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(4, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
pd3dDevice->SetTextureStageState(5, D3DTSS_COLOROP, D3DTOP_DISABLE);
pd3dDevice->SetTextureStageState(5, D3DTSS_COLORARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(5, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
pd3dDevice->SetTextureStageState(5, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
pd3dDevice->SetTextureStageState(5, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(5, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
pd3dDevice->SetTextureStageState(6, D3DTSS_COLOROP, D3DTOP_DISABLE);
pd3dDevice->SetTextureStageState(6, D3DTSS_COLORARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(6, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
pd3dDevice->SetTextureStageState(6, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
pd3dDevice->SetTextureStageState(6, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(6, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
pd3dDevice->SetTextureStageState(7, D3DTSS_COLOROP, D3DTOP_DISABLE);
pd3dDevice->SetTextureStageState(7, D3DTSS_COLORARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(7, D3DTSS_COLORARG2, D3DTA_DIFFUSE);
pd3dDevice->SetTextureStageState(7, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
pd3dDevice->SetTextureStageState(7, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
pd3dDevice->SetTextureStageState(7, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE);
pd3dDevice->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0);
pd3dDevice->SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 1);
pd3dDevice->SetTextureStageState(2, D3DTSS_TEXCOORDINDEX, 2);
pd3dDevice->SetTextureStageState(3, D3DTSS_TEXCOORDINDEX, 3);
pd3dDevice->SetTextureStageState(4, D3DTSS_TEXCOORDINDEX, 4);
pd3dDevice->SetTextureStageState(5, D3DTSS_TEXCOORDINDEX, 5);
pd3dDevice->SetTextureStageState(6, D3DTSS_TEXCOORDINDEX, 6);
pd3dDevice->SetTextureStageState(7, D3DTSS_TEXCOORDINDEX, 7);
pd3dDevice->SetTextureStageState(0, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(0, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(1, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(1, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(1, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(2, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(2, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(2, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(3, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(3, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(3, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(4, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(4, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(4, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(5, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(5, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(5, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(6, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(6, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(6, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(7, D3DTSS_MINFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(7, D3DTSS_MAGFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(7, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);
pd3dDevice->SetTextureStageState(0, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
pd3dDevice->SetTextureStageState(0, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
pd3dDevice->SetTextureStageState(1, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
pd3dDevice->SetTextureStageState(1, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
pd3dDevice->SetTextureStageState(2, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
pd3dDevice->SetTextureStageState(2, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
pd3dDevice->SetTextureStageState(3, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
pd3dDevice->SetTextureStageState(3, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
pd3dDevice->SetTextureStageState(4, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
pd3dDevice->SetTextureStageState(4, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
pd3dDevice->SetTextureStageState(5, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
pd3dDevice->SetTextureStageState(5, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
pd3dDevice->SetTextureStageState(6, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
pd3dDevice->SetTextureStageState(6, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
pd3dDevice->SetTextureStageState(7, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
pd3dDevice->SetTextureStageState(7, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
pd3dDevice->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
pd3dDevice->SetTextureStageState(1, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
pd3dDevice->SetTextureStageState(2, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
pd3dDevice->SetTextureStageState(3, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
pd3dDevice->SetTextureStageState(4, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
pd3dDevice->SetTextureStageState(5, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
pd3dDevice->SetTextureStageState(6, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
pd3dDevice->SetTextureStageState(7, D3DTSS_TEXTURETRANSFORMFLAGS, 0);
pd3dDevice->SetRenderState( D3DRS_WRAP0, 0);
pd3dDevice->SetRenderState( D3DRS_WRAP1, 0);
pd3dDevice->SetRenderState( D3DRS_WRAP2, 0);
pd3dDevice->SetRenderState( D3DRS_WRAP3, 0);
pd3dDevice->SetRenderState( D3DRS_WRAP4, 0);
pd3dDevice->SetRenderState( D3DRS_WRAP5, 0);
pd3dDevice->SetRenderState( D3DRS_WRAP6, 0);
pd3dDevice->SetRenderState( D3DRS_WRAP7, 0);
pd3dDevice->SetTexture(0, NULL);
pd3dDevice->SetTexture(1, NULL);
pd3dDevice->SetTexture(2, NULL);
pd3dDevice->SetTexture(3, NULL);
pd3dDevice->SetTexture(4, NULL);
pd3dDevice->SetTexture(5, NULL);
pd3dDevice->SetTexture(6, NULL);
pd3dDevice->SetTexture(7, NULL);
pd3dDevice->SetPixelShader(0);
}
| C++ |
#include "d3dbuffer.h"
#include "core_def.h"
#include "d3ddevice.h"
CD3DBuffer::CD3DBuffer()
{
m_pD3DVertexBuffer = NULL;
m_pD3DIndexBuffer = NULL;
}
CD3DBuffer::~CD3DBuffer()
{
GTH_SAFE_RELEASE( m_pD3DVertexBuffer );
GTH_SAFE_RELEASE( m_pD3DIndexBuffer );
}
void CD3DBuffer::Release()
{
GTH_SAFE_RELEASE( m_pD3DVertexBuffer );
GTH_SAFE_RELEASE( m_pD3DIndexBuffer );
}
int CD3DBuffer::Create( int size, DWORD format, DWORD bufType )
{
m_type = bufType;
m_format = format;
m_maxSize = size;
m_usedSize = 0;
m_ptrBuffer = NULL;
m_base = 0;
GTH_SAFE_RELEASE( m_pD3DVertexBuffer );
GTH_SAFE_RELEASE( m_pD3DIndexBuffer );
if( bufType & GTH_VERTEX_BUFFER )
return CreateVertexBuffer( size , format , bufType );
else if( bufType & GTH_INDEX_BUFFER )
return CreateIndexBuffer( size , format , bufType );
return false;
}
int CD3DBuffer::CreateIndexBuffer( int size, DWORD format, DWORD bufType )
{
int offset = 0;
DWORD usageFlag = 0;
D3DFORMAT d3dFormat = D3DFMT_INDEX16;
if( format & GTH_FORMAT_INDEX16 )
{
d3dFormat = D3DFMT_INDEX16;
offset = sizeof( WORD );
}
else if( format & GTH_FORMAT_INDEX32 )
{
d3dFormat = D3DFMT_INDEX32;
offset = sizeof( DWORD );
}
m_strideSize = offset;
if( bufType & GTH_DYNAMIC_BUFFER )
usageFlag = D3DUSAGE_DYNAMIC;
if( bufType & GTH_WRITEONLY )
usageFlag |= D3DUSAGE_WRITEONLY;
if( FAILED( g_d3dDevice.GetD3DDevice()->CreateIndexBuffer( m_strideSize * m_maxSize , usageFlag
, d3dFormat, D3DPOOL_DEFAULT , &m_pD3DIndexBuffer ) ) )
{
GTH_ERROR( GTH_ERROR_PRINT , "could not create index buffer" );
return false;
}
m_isLocked = false;
return true;
}
int CD3DBuffer::CreateVertexBuffer( int size, DWORD format, DWORD bufType )
{
int offset = 0;
DWORD usageFlag = 0;
DWORD d3dFormat = 0;
if( format & GTH_FORMAT_XYZ )
{
d3dFormat = D3DFVF_XYZ;
m_offsetVertex = 0;
offset += sizeof( float ) * 3;
}
else if( format & GTH_FORMAT_XYZRHW )
{
d3dFormat = D3DFVF_XYZRHW;
m_offsetVertex = 0;
offset += sizeof( float ) * 4;
}
if( format & GTH_FORMAT_NORMAL )
{
d3dFormat |= D3DFVF_NORMAL;
m_offsetNormal = offset;
offset += sizeof( float ) * 3;
}
if( format & GTH_FORMAT_DIFFUSE )
{
d3dFormat |= D3DFVF_DIFFUSE;
m_offsetDiffuse = offset;
offset += sizeof( DWORD );
}
if( format & GTH_FORMAT_SPECULAR )
{
d3dFormat |= D3DFVF_SPECULAR;
m_offsetSpecular = offset;
offset += sizeof( DWORD );
}
if( format & GTH_FORMAT_TEXVERTEXFLAG )
{
int nTexVertex = (format & ~GTH_FORMAT_TEXVERTEXFLAG ) >> 8;
switch( nTexVertex )
{
case 0:
d3dFormat |= D3DFVF_TEX0;
break;
case 1:
d3dFormat |= D3DFVF_TEX1;
break;
case 2:
d3dFormat |= D3DFVF_TEX2;
break;
case 3:
d3dFormat |= D3DFVF_TEX3;
break;
case 4:
d3dFormat |= D3DFVF_TEX4;
break;
case 5:
d3dFormat |= D3DFVF_TEX5;
break;
case 6:
d3dFormat |= D3DFVF_TEX6;
break;
case 7:
d3dFormat |= D3DFVF_TEX7;
break;
case 8:
d3dFormat |= D3DFVF_TEX8;
break;
default:
GTH_ERROR( GTH_ERROR_PRINT , "vertex buffer couldn't have more than 8 texture coord" );
break;
}
m_offsetTexVertex = offset;
m_strideTexVertex = sizeof( float ) * 2;
offset += m_strideTexVertex * nTexVertex;
}
m_strideSize = offset;
if( bufType & GTH_DYNAMIC_BUFFER )
usageFlag = D3DUSAGE_DYNAMIC;
if( bufType & GTH_WRITEONLY )
usageFlag |= D3DUSAGE_WRITEONLY;
if( FAILED( g_d3dDevice.GetD3DDevice()->CreateVertexBuffer( m_strideSize * m_maxSize , usageFlag
, d3dFormat, D3DPOOL_DEFAULT , &m_pD3DVertexBuffer ) ) )
{
GTH_ERROR( GTH_ERROR_PRINT , "could not create vertex buffer" );
return false;
}
m_isLocked = false;
return true;
}
void CD3DBuffer::Discard()
{
m_usedSize = m_maxSize;
}
BYTE *CD3DBuffer::Lock( const int sizeToLock )
{
if( m_type & GTH_VERTEX_BUFFER )
return LockVertexBuffer( sizeToLock );
else if( m_type & GTH_INDEX_BUFFER )
return LockIndexBuffer( sizeToLock );
return NULL;
}
int CD3DBuffer::CheckFreeSize( int sizeToLock )
{
if( m_usedSize + sizeToLock >= m_maxSize )
return false;
return true;
}
inline BYTE *CD3DBuffer::LockVertexBuffer( const int sizeToLock )
{
HRESULT ret;
if( m_usedSize + sizeToLock >= m_maxSize )
m_usedSize = m_maxSize;
if( sizeToLock == 0 )
{
if( m_type & GTH_DYNAMIC_BUFFER )
ret = m_pD3DVertexBuffer->Lock( 0, 0, (BYTE**) &m_ptrBuffer, D3DLOCK_DISCARD );
else
ret = m_pD3DVertexBuffer->Lock( 0, 0, (BYTE**) &m_ptrBuffer, NULL );
m_base = 0;
m_usedSize = m_maxSize;
}
else if( m_usedSize + sizeToLock >= m_maxSize )
{
if( m_type & GTH_DYNAMIC_BUFFER )
ret = m_pD3DVertexBuffer->Lock( 0, m_strideSize * sizeToLock, (BYTE**) &m_ptrBuffer, D3DLOCK_DISCARD );
else
ret = m_pD3DVertexBuffer->Lock( 0, m_strideSize * sizeToLock, (BYTE**) &m_ptrBuffer, NULL );
m_base = 0;
m_usedSize = sizeToLock;
}
else
{
if( m_type & GTH_DYNAMIC_BUFFER )
ret = m_pD3DVertexBuffer->Lock( m_strideSize * m_usedSize, m_strideSize * sizeToLock, (BYTE**) &m_ptrBuffer, D3DLOCK_NOOVERWRITE );
else
ret = m_pD3DVertexBuffer->Lock( m_strideSize * m_usedSize, m_strideSize * sizeToLock, (BYTE**) &m_ptrBuffer, NULL );
m_base = m_usedSize;
m_usedSize += sizeToLock;
}
if( ret != D3D_OK )
{
GTH_ERROR( GTH_ERROR_PRINT , "could not Lock vertex buffer" );
}
m_isLocked = true ;
return m_ptrBuffer;
}
inline BYTE *CD3DBuffer::LockIndexBuffer( const int sizeToLock )
{
HRESULT ret;
if( m_usedSize + sizeToLock >= m_maxSize )
m_usedSize = m_maxSize;
if( sizeToLock == 0 )
{
if( m_type & GTH_DYNAMIC_BUFFER )
ret = m_pD3DIndexBuffer->Lock( 0, 0, (BYTE**) &m_ptrBuffer, D3DLOCK_DISCARD );
else
ret = m_pD3DIndexBuffer->Lock( 0, 0, (BYTE**) &m_ptrBuffer, NULL );
m_base = 0;
m_usedSize = m_maxSize;
}
else if( m_usedSize + sizeToLock >= m_maxSize )
{
if( m_type & GTH_DYNAMIC_BUFFER )
ret = m_pD3DIndexBuffer->Lock( 0, m_strideSize * sizeToLock, (BYTE**) &m_ptrBuffer
, D3DLOCK_DISCARD );
else
ret = m_pD3DIndexBuffer->Lock( 0, m_strideSize * sizeToLock, (BYTE**) &m_ptrBuffer
, NULL );
m_base = 0;
m_usedSize = sizeToLock;
}
else
{
if( m_type & GTH_DYNAMIC_BUFFER )
ret = m_pD3DIndexBuffer->Lock( m_strideSize * m_usedSize, m_strideSize * sizeToLock
, (BYTE**) &m_ptrBuffer, D3DLOCK_NOOVERWRITE );
else
ret = m_pD3DIndexBuffer->Lock( m_strideSize * m_usedSize, m_strideSize * sizeToLock
, (BYTE**) &m_ptrBuffer, NULL );
m_base = m_usedSize;
m_usedSize += sizeToLock;
}
if( ret != D3D_OK )
{
GTH_ERROR( GTH_ERROR_PRINT , "could not Lock index buffer" );
}
m_isLocked = true;
return m_ptrBuffer;
}
void CD3DBuffer::Unlock()
{
HRESULT ret;
if( m_type & GTH_VERTEX_BUFFER )
ret = m_pD3DVertexBuffer->Unlock();
else if( m_type & GTH_INDEX_BUFFER )
ret = m_pD3DIndexBuffer->Unlock();
if( ret != D3D_OK )
{
GTH_ERROR( GTH_ERROR_PRINT , "could not UnLock buffer" );
}
m_isLocked = false;
m_ptrBuffer = NULL;
}
| C++ |
#include "camera.h"
#include "surfaceflags.h"
#define DEGREE_QUARTER_VIEW 20.0f
#define DEGREE_TOP_VIEW 89.0f
CCamera g_camera;
CCamera::CCamera()
{
m_distance = -200.0f;
m_isThirdPerson = true;
m_autoFollow = true;
VectorClear( m_position );
VectorSet( m_angles , DEGREE_QUARTER_VIEW , 0.0f , 0.0f );
m_projectParm.fov = 90.0f;
m_projectParm.znear = GTH_PROJECT_NEAR_PLANE;
m_projectParm.zfar = 5000.0f;
m_minCamDist = -40.0f;
m_maxCamDist = -950.0f; //lucky Cam distance.
m_viewType = CAMERA_VIEWTYPE_PLAYER_BACK | CAMERA_VIEWTYPE_QUATER_VIEW;
m_characterAngle = 0.0f;
m_world = NULL;
}
CCamera::~CCamera()
{
}
void CCamera::SetProjectParameter( float znear , float zfar )
{
m_projectParm.znear = znear;
m_projectParm.zfar = zfar;
}
#define YAW 1
#define PITCH 0
void CCamera::SetupMatrices( int isFrustumSetup )
{
vec3_t negPos;
SetupVectors();
m_worldMat.Identity();
m_viewMat.Identity();
m_viewMat.m[0] = m_right[0];
m_viewMat.m[4] = m_right[1];
m_viewMat.m[8] = m_right[2];
m_viewMat.m[1] = m_up[0];
m_viewMat.m[5] = m_up[1];
m_viewMat.m[9] = m_up[2];
m_viewMat.m[2] = m_forward[0];
m_viewMat.m[6] = m_forward[1];
m_viewMat.m[10] = m_forward[2];
VectorNegate( negPos , m_position );
m_viewMat.Translate( negPos );
D3DXMatrixInverse( (D3DXMATRIX*) &m_invProjMat , NULL , (D3DXMATRIX*) &m_projMat );
D3DXMatrixInverse( (D3DXMATRIX*) &m_invViewMat , NULL , (D3DXMATRIX*) &m_viewMat );
D3DXMatrixInverse( (D3DXMATRIX*) &m_invWorldMat , NULL , (D3DXMATRIX*) &m_worldMat );
matrix4x4_t::Multiply( m_envMat , m_worldMat , m_viewMat );
matrix4x4_t::Multiply( m_transMat , m_envMat , m_projMat );
matrix4x4_t::Multiply( m_envMat , m_invProjMat , m_invViewMat );
matrix4x4_t::Multiply( m_invTransMat , m_envMat , m_invWorldMat );
matrix4x4_t::Multiply( m_envMat , m_viewMat , m_worldMat );
if( isFrustumSetup )
m_frustum.Setup( m_angles , m_position , &m_projectParm );
}
void CCamera::SetFovY(double fovy, double aspect, double znear, double zfar)
{
m_projMat.Projection_LH( fovy , aspect , znear , zfar );
}
void CCamera::SetupViewPort( int x , int y , int width , int height , float minZ , float maxZ )
{
viewport_t *viewport;
viewport = &m_projectParm.viewport;
viewport->X = x;
viewport->Y = y;
viewport->Width = width;
viewport->Height = height;
viewport->MinZ = minZ;
viewport->MaxZ = maxZ;
}
#define CAMERA_VIEW_HEIGHT 60.0f
#define CAMERA_AUTO_ROTATE_ANGLE 5.0f
void CCamera::AdjustCameraAngle( vec3_t pos , vec3_t angles , float elapsedTime )
{
float deltaAngle , rotate;
if( !m_autoFollow ) return;
if( m_angles[ YAW ] != angles[ YAW ] && ( m_characterPos[0] != pos[0] || m_characterPos[1] != pos[1] ) )
{
rotate = CAMERA_AUTO_ROTATE_ANGLE * elapsedTime;
deltaAngle = angles[ YAW ] - m_angles[ YAW ];
if( deltaAngle > 10.0f )
{
if( deltaAngle > 190.0f )
{
deltaAngle = 360.0f - deltaAngle;
if( rotate > deltaAngle ) rotate = deltaAngle;
m_angles[ YAW ] -= rotate;
}
else if( deltaAngle < 170.0f )
{
if( rotate > deltaAngle ) rotate = deltaAngle;
m_angles[ YAW ] += rotate;
}
}
else if( deltaAngle < -10.0f )
{
if( deltaAngle < -190.0f )
{
deltaAngle = deltaAngle + 360.0f;
if( rotate > deltaAngle ) rotate = deltaAngle;
m_angles[ YAW ] += rotate;
}
else if( deltaAngle > -170.0f )
{
if( rotate > -deltaAngle ) rotate = deltaAngle;
m_angles[ YAW ] -= rotate;
}
}
if( m_angles[ YAW ] < 0.0f ) m_angles[ YAW ] += 360.0f;
if( m_angles[ YAW ] > 360.0f ) m_angles[ YAW ] -= 360.0f;
}
}
void CCamera::AdjustCamera( vec3_t pos , vec3_t angles )
{
int flag;
vec3_t point;
m_characterAngle = angles[ YAW ];
VectorCopy( m_characterPos , pos );
VectorCopy( point , pos );
point[2] = point[2] + CAMERA_VIEW_HEIGHT;
if( !m_isThirdPerson )
{
VectorCopy( m_position , pos );
m_position[2] = m_position[2] + CAMERA_VIEW_HEIGHT;
return;
}
flag = CheckCameraPos( point , m_distance , m_angles );
if( !flag )
{
Zoom(15*5);
if( m_distance >= -40.0f ) m_distance = -30.0f;
flag = CheckCameraPos( point , m_distance , m_angles );
}
}
int CCamera::CheckCameraPos( vec3_t pos , float dist , vec3_t angles )
{
vec3_t forward , end;
trace_t trace;
vec3_t mins , maxs;
AngleToVector( angles , forward );
VectorScale( forward , forward , dist );
VectorAdd( end , pos , forward );
mins[0] = -10.0f; mins[1] = -10.0f; mins[2] = -10.0f;
maxs[0] = 10.0f; maxs[1] = 10.0f; maxs[2] = 10.0f;
trace = m_world->Trace( pos , mins , maxs , end , MASK_PLAYERSOLID );
if( trace.fraction == 1.0f )
{
VectorCopy( m_position , end );
return true;
}
if( trace.fraction < 0.2f || trace.fraction * dist < 30.0f )
{
VectorScale( forward , forward , 1.0f );
VectorAdd( m_position , pos , forward );
return false;
}
else if( trace.fraction < 0.5f )
{
VectorScale( forward , forward , trace.fraction * 0.8f );
VectorAdd( m_position , pos , forward );
return true;
}
else
{
VectorScale( forward , forward , trace.fraction * 0.9f );
VectorAdd( m_position , pos , forward );
return true;
}
}
void CCamera::Zoom( int value )
{
float zoomScale;
zoomScale = (float) value / 5.0f;
m_distance += zoomScale;
if( m_distance > m_minCamDist )
m_distance = m_minCamDist;
if( m_distance < m_maxCamDist )
m_distance = m_maxCamDist;
}
void CCamera::RotateAngles( vec3_t rotate )
{
VectorAdd( m_angles , m_angles , rotate );
AdjustAngles();
}
inline void CCamera::AdjustAngles()
{
if( m_angles[ PITCH ] < -60.0f ) m_angles[ PITCH ] = -60.0f;
if( m_angles[ PITCH ] > 89.0f ) m_angles[ PITCH ] = 89.0f;
if( m_angles[ YAW ] < 0.0f ) m_angles[ YAW ] += 360.0f;
if( m_angles[ YAW ] > 360.0f ) m_angles[ YAW ] -= 360.0f;
}
void CCamera::SetAngles( vec3_t angles )
{
VectorCopy( m_angles , angles );
AdjustAngles();
}
void CCamera::GetFwdVector( vec3_t vec )
{
VectorSet( vec , m_forward[0] , m_forward[1] , m_forward[2] );
}
void CCamera::GetRightVector( vec3_t vec )
{
VectorSet( vec , m_right[0] , m_right[1] , m_right[2] );
}
void CCamera::GetUpVector( vec3_t vec )
{
VectorSet( vec , m_up[0] , m_up[1] , m_up[2] );
}
void CCamera::Reset()
{
VectorClear( m_position );
VectorSet( m_angles , m_angles[0] , 0.0f , 0.0f );
}
void CCamera::SetViewType( int type )
{
m_viewType = type;
if ( m_viewType & CAMERA_VIEWTYPE_PLAYER_BACK )
m_angles[ YAW ] = m_characterAngle;
else if( m_viewType & CAMERA_VIEWTYPE_PLAYER_FRONT )
m_angles[ YAW ] = m_characterAngle + 180.0f;
else if( m_viewType & CAMERA_VIEWTYPE_PLAYER_RIGHT )
m_angles[ YAW ] = m_characterAngle + 90.0f;
else if( m_viewType & CAMERA_VIEWTYPE_PLAYER_LEFT )
m_angles[ YAW ] = m_characterAngle + 270.0f;
if ( m_viewType & CAMERA_VIEWTYPE_QUATER_VIEW )
m_angles[ PITCH ] = DEGREE_QUARTER_VIEW;
else if( m_viewType & CAMERA_VIEWTYPE_TOP_VIEW )
m_angles[ PITCH ] = DEGREE_TOP_VIEW;
AdjustAngles();
} | C++ |
#include "script.h"
#include "filemng.h"
CScript g_script;
CScript::CScript()
{
m_name[0] = NULL;
m_token[0] = NULL;
m_buffer = NULL;
m_prevOffset = NULL;
m_currOffset = NULL;
m_bufferSize = 0;
m_lines = 0;
}
CScript::~CScript()
{
GTH_SAFE_FREE( m_buffer );
}
void CScript::Reset()
{
GTH_SAFE_FREE( m_buffer );
m_name[0] = NULL;
m_token[0] = NULL;
m_prevOffset = NULL;
m_currOffset = NULL;
m_bufferSize = 0;
m_lines = 0;
}
int CScript::Load( char *fName )
{
if( m_buffer ) Reset();
strcpy( m_name , fName );
m_bufferSize = g_fileMng.GetFileSizeFromPack( fName );
if( !m_bufferSize ) return false;
m_buffer = g_fileMng.ReadFileFromPack( fName );
if( !m_buffer ) return false;
m_buffer[ m_bufferSize - 1 ] = 0;
return true;
}
int CScript::Load( char *fName , DWORD size , BYTE *data )
{
if( !size ) return false;
if( !data ) return false;
if( m_buffer ) Reset();
strcpy( m_name , fName );
m_bufferSize = size;
m_buffer = data;
m_buffer[ m_bufferSize - 1 ] = 0;
return true;
}
int CScript::SkipSpace()
{
int ch;
int hasNewLines = false;
while( (ch = *m_currOffset) <= ' ') {
if( !ch ) {
m_currOffset = NULL;
return hasNewLines;
}
if( ch == '\n' ) {
m_lines++;
hasNewLines = true;
}
m_currOffset++;
}
return hasNewLines;
}
char * CScript::GetNextToken()
{
return GetNextToken( true );
}
char * CScript::GetNextToken(int allowLineBreak)
{
int ch = 0, len;
int hasNewLines = false;
m_currOffset = m_prevOffset;
len = 0;
m_token[0] = 0;
if ( !m_currOffset )
{
m_prevOffset = NULL;
return m_token;
}
while ( 1 )
{
hasNewLines = SkipSpace();
if ( !m_currOffset )
{
m_prevOffset = NULL;
return m_token;
}
if ( hasNewLines && !allowLineBreak )
{
m_prevOffset = m_currOffset;
return m_token;
}
ch = *m_currOffset;
if ( ch == '/' && m_currOffset[1] == '/' )
{
while (*m_currOffset && *m_currOffset != '\n')
m_currOffset++;
}
else if ( ch == '/' && m_currOffset[1] == '*' )
{
while ( *m_currOffset && ( *m_currOffset != '*' || m_currOffset[1] != '/' ) )
{
m_currOffset++;
}
if ( *m_currOffset )
{
m_currOffset += 2;
}
}
else
{
break;
}
}
if (ch == '\"')
{
m_currOffset++;
while (1)
{
ch = *m_currOffset++;
if (ch == '\"' || !ch)
{
m_token[len] = 0;
m_prevOffset = m_currOffset;
return m_token;
}
if (len < GTH_MAX_SIZE_TOKEN)
{
m_token[len] = ch;
len++;
}
}
}
do
{
if (len < GTH_MAX_SIZE_TOKEN)
{
m_token[len] = ch;
len++;
}
m_currOffset++;
ch = *m_currOffset;
if ( ch == '\n' )
m_lines++;
} while (ch > 32);
if (len == GTH_MAX_SIZE_TOKEN)
{
GTH_ERROR( GTH_ERROR_OVERFLOW_SIZE , m_name );
len = 0;
}
m_token[len] = 0;
m_prevOffset = m_currOffset;
return m_token;
}
char * CScript::GetCurrToken()
{
return m_token;
}
int CScript::SetOffset(int offset)
{
return true;
}
void CScript::SkipLine()
{
BYTE *p;
int ch;
p = m_currOffset;
while ( (ch = *p++) != 0 ) {
if ( ch == '\n' ) {
m_lines++;
break;
}
}
m_currOffset = p;
m_prevOffset = m_currOffset;
}
char * CScript::GetName()
{
return m_name;
}
void CScript::BeginParse()
{
m_currOffset = m_buffer;
m_prevOffset = m_buffer;
m_token[0] = NULL;
m_lines = 0;
}
int CScript::GetCurrParseLine()
{
return m_lines;
}
void CScript::SkipBracedSection()
{
char *token;
int depth;
depth = 0;
do {
token = GetNextToken( true );
if( token[1] == 0 ) {
if( token[0] == '{' ) {
depth++;
}
else if( token[0] == '}' ) {
depth--;
}
}
} while( depth && m_currOffset );
}
int CScript::MatchToken(char *match)
{
char *token;
token = GetNextToken( true );
if ( stricmp( token, match ) ) {
GTH_ERROR( GTH_ERROR_PRINT , match );
return false;
}
return true;
}
int CScript::GetCSVToken( char token[] )
{
int l = 0;
int ret = 0;
BYTE *endOffset = m_prevOffset + m_bufferSize;
memset( token, 0, sizeof( token ) );
while ( m_currOffset < endOffset )
{
while ( 1 )
{
if( IsDBCSLeadByte( (BYTE)*m_currOffset ) )
{
token[l] = *m_currOffset; l ++; m_currOffset ++;
token[l] = *m_currOffset; l ++; m_currOffset ++;
}
else if( *m_currOffset == ',' || *m_currOffset == '\r' )
{
break;
}
else if( m_currOffset >= endOffset )
{
ret = 1;
break;
}
else
{
token[l] = *m_currOffset; l ++; m_currOffset ++;
}
}
if( *m_currOffset == '\r' )
{
m_currOffset ++;
m_currOffset ++;
if( m_currOffset >= endOffset )
{
ret = 1;
break;
}
ret = 2;
}
else
{
m_currOffset ++;
}
token[l] = '\0';
return( ret );
}
ret = 1;
return( ret );
}
| C++ |
#if !defined(AFX_RESMANAGER_H__53529D1A_A3FC_4AB4_975D_4E5B098E1D7B__INCLUDED_)
#define AFX_RESMANAGER_H__53529D1A_A3FC_4AB4_975D_4E5B098E1D7B__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#pragma warning( disable : 4786 )
#pragma warning( disable : 4251 )
#include <ctime>
#include <map>
#include <stack>
enum ResourceType
{
RESOURCE_TYPE_NORMAL,
RESOURCE_TYPE_MODEL,
RESOURCE_TYPE_TEXTURE,
RESOURCE_TYPE_SOUND,
NUM_RESOURCE_TYPE
};
#define RES_INIT_CREATE 0x00000000
#define RES_INIT_NOTCREATE 0x00000001
#define RHANDLE unsigned int
#define INVALID_RHANDLE 0xFFFFFFFF
#define IS_INVALID_RHANDLE(_rh) ((_rh == INVALID_RHANDLE) ? true : false)
#define IS_VALID_RHANDLE(_rh) ((_rh == INVALID_RHANDLE) ? false : true)
class BaseResource
{
public:
enum PriorityType
{
RES_LOW_PRIORITY = 0,
RES_MED_PRIORITY,
RES_HIGH_PRIORITY
};
BaseResource() { Clear(); }
virtual ~BaseResource() { Destroy(); }
virtual void Clear();
virtual bool Create( char *fname, int iSize ) { return false; }
virtual bool Register( char *fname, int iSize ) { return false; }
virtual void Destroy() {}
virtual bool Recreate() = 0;
virtual void Dispose() = 0;
virtual size_t GetSize() = 0;
virtual bool IsDisposed() = 0;
inline void SetPriority( PriorityType priority ) { m_Priority = priority; }
inline PriorityType GetPriority() { return m_Priority; }
inline void SetReferenceCount( unsigned int nCount ) { m_nRefCount = nCount; }
inline unsigned int GetReferenceCount() { return m_nRefCount; }
inline bool IsLocked() { return (m_nRefCount > 0) ? true : false; }
inline void SetLastAccess( time_t LastAccess ) { m_LastAccess = LastAccess; }
inline time_t GetLastAccess() { return m_LastAccess; }
virtual bool operator < (BaseResource& container);
protected:
PriorityType m_Priority;
unsigned int m_nRefCount;
time_t m_LastAccess;
};
template <class T>
class ptr_less
{
public:
inline bool operator ()(T left, T right)
{ return ((*left) < (*right)); }
};
template <class T>
class ptr_greater
{
public:
inline bool operator ()(T left, T right)
{ return !((*left) < (*right)); }
};
typedef std::map<RHANDLE, BaseResource*> ResMap;
typedef ResMap::iterator ResMapItor;
typedef ResMap::value_type ResMapPair;
class CResManager
{
public:
CResManager();
virtual ~CResManager();
void Clear();
bool Create( unsigned int nMaxSize );
void Destroy();
bool SetMaximumMemory( size_t nMem );
size_t GetMaximumMemory() { return m_nMaximumMemory; }
size_t GetUsedMemory() { return m_nCurrentUsedMemory; }
inline void GotoBegin() { m_CurrentResource = m_ResourceMap.begin(); }
inline BaseResource* GetCurrentResource() { return (*m_CurrentResource).second; }
inline bool GotoNext() { m_CurrentResource++; return IsValid(); }
inline bool IsValid() { return (m_CurrentResource != m_ResourceMap.end()) ? true : false; }
bool ReserveMemory( size_t nMem );
bool InsertResource( RHANDLE* rhUniqueID, BaseResource* pResource );
bool InsertResource( RHANDLE rhUniqueID, BaseResource* pResource );
bool RegisterResource( RHANDLE rhUniqueID, BaseResource* pResource );
bool RemoveResource( BaseResource* pResource );
bool RemoveResource( RHANDLE rhUniqueID );
bool DestroyResource( BaseResource* pResource );
bool DestroyResource( RHANDLE rhUniqueID );
BaseResource* GetResource( RHANDLE rhUniqueID );
BaseResource* Lock( RHANDLE rhUniqueID );
int Unlock( RHANDLE rhUniqueID );
int Unlock( BaseResource* pResource );
RHANDLE FindResourceHandle( BaseResource* pResource );
ResourceType GetResourceType() { return m_resourceType; }
inline void SetResourceType( ResourceType type ) { m_resourceType = type; }
protected:
inline void AddMemory( size_t nMem ) { m_nCurrentUsedMemory += nMem; }
inline void RemoveMemory( size_t nMem ) { m_nCurrentUsedMemory -= nMem; }
unsigned int GetNextResHandle() { return --m_rhNextResHandle; }
bool CheckForOverallocation();
protected:
RHANDLE m_rhNextResHandle;
size_t m_nCurrentUsedMemory;
size_t m_nMaximumMemory;
bool m_bResourceReserved;
ResMapItor m_CurrentResource;
ResMap m_ResourceMap;
ResourceType m_resourceType;
};
#endif
| C++ |
#include "bsp.h"
#include "d3drender.h"
void CBSP::SetShadowRenderState()
{
g_d3dRender.SetVertexShader( m_shadowFormat );
g_d3dRender.SetStreamSource( 0 , m_shadowVB->GetD3DVertexBuffer() , m_shadowVB->GetStrideSize() );
g_d3dRender.SetIndices( m_dynamicIB->GetD3DIndexBuffer() , 0 );
m_shadowVB->Discard();
g_d3dRender.SetShadowRenderState();
}
void CBSP::RenderProjectiveShadow( vec3_t p1 , vec3_t p2 , vec3_t p3 , vec3_t p4 , LPDIRECT3DTEXTURE8 d3dTex )
{
vec3_t origin , sub;
float dist , size , gridSize;
int rowStart , rowEnd , colStart , colEnd;
gridfacelump_t *faceLump;
gridfacelist_t *faceList;
face_t *face;
int i , j , k , l;
vertex_t *vert;
vec3_t pointOnPlane , diff;
shadowvertex_t *ptrVB;
WORD *ptrIB , *elem;
WORD baseIdxVB , offsetVB;
int sizeLoop;
int sizeRenderElems;
int sizeRenderVerts;
VectorAdd( origin , p1 , p3 );
VectorScale( origin , origin , 0.5f );
VectorSubtract( sub , p3 , origin );
size = (float) sqrt( VectorDotProduct( sub , sub ) );
gridSize = m_gridFaceLumpHead->gridSize;
colStart = (int) ( ( origin[0] - size - m_gridFaceLumpHead->mins[0] ) / gridSize );
colEnd = (int) ( ( origin[0] + size - m_gridFaceLumpHead->mins[0] + gridSize - 1.0f ) / gridSize );
rowStart = (int) ( ( origin[1] - size - m_gridFaceLumpHead->mins[1] ) / gridSize );
rowEnd = (int) ( ( origin[1] + size - m_gridFaceLumpHead->mins[1] + gridSize - 1.0f ) / gridSize );
g_d3dRender.SetTexture( 0 , d3dTex );
m_shadowFrameFlag++;
sizeRenderVerts = 0;
sizeRenderElems = 0;
for( i = rowStart ; i <= rowEnd ; i++ )
{
for( j = colStart ; j <= colEnd ; j++ )
{
faceLump = &m_gridFaceLumps[ i * m_gridFaceLumpHead->width + j ];
faceList = &m_gridFaceLists[ faceLump->base ];
for( k = 0 ; k < faceLump->sizeLumps ; faceList++ , k++ )
{
face = &m_faces[ *faceList ];
if( face->type == FACETYPE_PATCH ) continue;
if( face->frameFlag == m_shadowFrameFlag ) continue;
else
face->frameFlag = m_shadowFrameFlag;
sizeRenderVerts += face->sizeVB;
sizeRenderElems += face->sizeEB;
}
}
}
m_shadowFrameFlag++;
ptrVB = (shadowvertex_t *) m_shadowVB->Lock( sizeRenderVerts );
ptrIB = (WORD *) m_dynamicIB->Lock( sizeRenderElems );
baseIdxVB = m_shadowVB->GetBase();
for( i = rowStart ; i <= rowEnd ; i++ )
{
for( j = colStart ; j <= colEnd ; j++ )
{
faceLump = &m_gridFaceLumps[ i * m_gridFaceLumpHead->width + j ];
faceList = &m_gridFaceLists[ faceLump->base ];
for( k = 0 ; k < faceLump->sizeLumps ; faceList++ , k++ )
{
face = &m_faces[ *faceList ];
if( face->type == FACETYPE_PATCH ) continue;
if( face->frameFlag == m_shadowFrameFlag ) continue;
else
face->frameFlag = m_shadowFrameFlag;
dist = VectorDotProduct( origin , face->planeNormal ) - face->planeDist;
VectorProjectOnPlane( pointOnPlane , origin , face->planeRight , face->planeUp );
if( m_shaderMaps[ face->shader ].flags & SHADER_DEFORMVERTEXES )
offsetVB = 0;
else
offsetVB = (WORD) face->offsetVB;
sizeLoop = face->sizeEB;
elem = &m_staticEB[ face->offsetEB ];
for( l = 0 ; l < sizeLoop ; l++ , ptrIB++ , elem++ )
*ptrIB = *elem - offsetVB + baseIdxVB;
sizeLoop = face->sizeVB;
vert = &m_vertices[ face->vertexOffset ];
for( l = 0 ; l < sizeLoop ; vert++ , ptrVB++ , l++ )
{
VectorCopy( ptrVB->point , vert->point );
VectorCopy( ptrVB->normal , vert->normal );
VectorSubtract( diff , vert->point , pointOnPlane );
ptrVB->texUV[0] = ( ( VectorDotProduct( diff , face->planeRight ) ) / ( ( size + dist ) * 2 ) ) + 0.5f;
ptrVB->texUV[1] = ( ( VectorDotProduct( diff , face->planeUp ) ) / ( ( size + dist ) * 2 ) ) + 0.5f;
}
baseIdxVB += face->sizeVB;
}
}
}
m_shadowVB->Unlock();
m_dynamicIB->Unlock();
m_totalRenderPolygon += sizeRenderElems / 3;
g_d3dRender.RenderDefault( m_shadowVB->GetBase() , sizeRenderVerts , m_dynamicIB->GetBase() , sizeRenderElems );
}
bool CBSP::RenderProjectiveShadowNeo( float in_size, vec3_t p1, CD3DBuffer* pBuffer, int& vertexSize )
{
float size , gridSize;
int rowStart , rowEnd , colStart , colEnd;
gridfacelump_t *faceLump;
gridfacelist_t *faceList;
face_t *face;
int i;
int j;
int k;
size = in_size;
gridSize = m_gridFaceLumpHead->gridSize;
colStart = (int) ( ( p1[0] - size - m_gridFaceLumpHead->mins[0] ) / gridSize );
colEnd = (int) ( ( p1[0] + size - m_gridFaceLumpHead->mins[0] + gridSize - 1.0f ) / gridSize );
rowStart = (int) ( ( p1[1] - size - m_gridFaceLumpHead->mins[1] ) / gridSize );
rowEnd = (int) ( ( p1[1] + size - m_gridFaceLumpHead->mins[1] + gridSize - 1.0f ) / gridSize );
if ( ( colStart < 0 ) ||
( colEnd < 0 ) ||
( rowStart < 0 ) ||
( rowEnd < 0 ) ) return false;
m_shadowFrameFlag++;
for( i = rowStart ; i <= rowEnd ; i++ )
{
for( j = colStart ; j <= colEnd ; j++ )
{
faceLump = &m_gridFaceLumps[ i * m_gridFaceLumpHead->width + j ];
faceList = &m_gridFaceLists[ faceLump->base ];
for( k = 0 ; k < faceLump->sizeLumps ; faceList++ , k++ )
{
face = &m_faces[ *faceList ];
if( face->type == FACETYPE_PATCH ) continue;
if( face->frameFlag == m_shadowFrameFlag ) continue;
else
face->frameFlag = m_shadowFrameFlag;
if (!m_decal.Process( *face ))
{
vertexSize = m_decal.GetVertexSize ();
if(vertexSize > 0 )
{
pBuffer ->Lock ( m_decal .GetVertexSize () );
m_decal.CopyVertex ( (void *)pBuffer ->GetBuffer() );
pBuffer->Unlock();
return true;
}
else
{
vertexSize = 0;
return false;
}
}
}
}
}
vertexSize = m_decal.GetVertexSize ();
if(vertexSize > 0 )
{
pBuffer ->Lock ( m_decal .GetVertexSize () );
m_decal.CopyVertex ( (void *)pBuffer ->GetBuffer() );
pBuffer->Unlock();
return true;
}
vertexSize = 0;
return false;
}
void CBSP::SetDecalBuffer()
{
m_decal .SetVertices ( m_vertices );
m_decal .SetIndices ( m_elems );
}
void CBSP::SetDecalInit(matrix4x4_t* matShadow, vec3_t& vLight, vec3_t& sunAngle, float dispPS, float min, float max)
{
m_decal .SetInvTransformMatrix ( matShadow );
m_decal .SetLight ( vLight );
m_decal .SetSunLight ( sunAngle );
m_decal .SetSize ( dispPS );
m_decal .Initialize ();
m_decal .SetMinMaxHeight ( min, max );
}
| C++ |
#include "shadermng.h"
#include "camera.h"
#include "script.h"
#include "timer.h"
#include "d3dtexturemng.h"
CShaderMng g_shaderMng;
CShaderMng::CShaderMng()
{
m_numShaders = 0;
m_numAnimMaps = 0;
m_numEnvSkys = 0;
}
CShaderMng::~CShaderMng()
{
m_numShaders = 0;
m_numAnimMaps = 0;
m_numEnvSkys = 0;
delete m_shaders;
}
CShaderMng::CShaderMng( int owner )
{
m_numShaders = 0;
m_numAnimMaps = 0;
m_numEnvSkys = 0;
m_owner = owner;
}
int CShaderMng::Init( int sizeShader )
{
if( sizeShader == 0 ) return true;
m_maxSizeShader = sizeShader;
m_shaders = new shader_t[ m_maxSizeShader ];
if( !m_shaders )
{
GTH_ERROR( GTH_ERROR_NOT_ENOUGH_MEMORY , "CShaderMng::Init::m_shaders" );
return false;
}
m_numShaders = 0;
return true;
}
int CShaderMng::GetShaderCount( char *fName , DWORD size , BYTE *data )
{
char *token;
int count;
if( data )
{
if( !g_script.Load( fName , size , data ) )
return 0;
}
else
{
if( !g_script.Load( fName ) )
return 0;
}
g_script.BeginParse();
count = 0;
while( 1 )
{
token = g_script.GetNextToken( true );
if( !token[0] ) break;
count++;
g_script.SkipBracedSection();
}
return count;
}
void CShaderMng::Release()
{
shader_t *shader;
shaderpass_t *pass;
int i , j;
for( i = 0 ; i < m_numShaders ; i++ )
{
shader = &m_shaders[ i ];
if( !shader->inited ) continue;
if( shader->flags & SHADER_SKY_ENVIRON )
{
for( i = 0 ; i < SIZE_ENVIRONMENT_SIDE ; i++ )
g_texMng.Release( shader->envSky->map[ i ] , m_owner );
}
pass = &shader->passes[0];
for( i = 0 ; i < shader->numPasses ; i++ , pass++ )
{
if( pass->flags & SHADERPASS_MAP )
g_texMng.Release( pass->map , m_owner );
else if( pass->flags & SHADERPASS_MAP_ANIMMAP )
{
anim_t *anim = pass->animMap;
for( j = 0 ; j < anim->numFrames ; j++ )
g_texMng.Release( anim->maps[ j ] , m_owner );
}
}
shader->inited = false;
}
}
void CShaderMng::Release( int idxShader )
{
shader_t* shader;
shaderpass_t* pass;
int i;
int j;
shader = &m_shaders[idxShader];
if(!shader->inited)
return;
if(shader->flags & SHADER_SKY_ENVIRON)
{
for(i = 0 ; i < SIZE_ENVIRONMENT_SIDE ; i++)
{
g_texMng.Release(shader->envSky->map[i], m_owner);
}
}
pass = &shader->passes[0];
for( i = 0 ; i < shader->numPasses ; i++ , pass++ )
{
if(pass->flags & SHADERPASS_MAP)
{
g_texMng.Release( pass->map , m_owner );
}
else if(pass->flags & SHADERPASS_MAP_ANIMMAP)
{
anim_t *anim = pass->animMap;
for(j = 0 ; j < anim->numFrames ; j++)
{
g_texMng.Release( anim->maps[ j ] , m_owner );
}
}
}
shader->inited = false;
}
int CShaderMng::GetShaderTexRef( char *textureName )
{
return g_texMng.Add( textureName , m_owner );
}
void CShaderMng::InitShader( int idxShader )
{
shader_t* shader;
shaderpass_t* pass;
int i;
int j;
shader = &m_shaders[idxShader];
if( shader->inited ) return;
if( shader->flags & SHADER_SKY_ENVIRON )
{
for(i = 0 ; i < SIZE_ENVIRONMENT_SIDE ; i++)
{
shader->envSky->texRef[i] = GetShaderTexRef( shader->envSky->map[ i ] );
}
}
pass = &shader->passes[0];
for( i = 0 ; i < shader->numPasses ; i++ , pass++ )
{
if( pass->flags & SHADERPASS_MAP )
{
pass->texRef = GetShaderTexRef( pass->map );
}
else if( pass->flags & SHADERPASS_MAP_ANIMMAP )
{
anim_t *anim = pass->animMap;
for( j = 0 ; j < anim->numFrames ; j++ )
{
anim->frames[ j ] = GetShaderTexRef( anim->maps[ j ] );
}
}
}
shader->inited = true;
}
int CShaderMng::SearchShader( char *name )
{
for(int i = 0 ; i < m_numShaders ; i++)
{
if(!stricmp( name , m_shaders[i].name))
{
return i;
}
}
return -1;
}
shader_t *CShaderMng::GetShader( int idx )
{
shader_t* shader;
shader = &m_shaders[ idx ];
if( shader->inited )
return shader;
else
return NULL;
}
shader_t *CShaderMng::GetShader( char *name )
{
shader_t* shader;
int i;
for( i = 0 ; i < m_numShaders ; i++ )
{
if( !stricmp( name , m_shaders[i].name ) )
{
break;
}
}
if( i == m_numShaders )
{
return NULL;
}
shader = &m_shaders[ i ];
if( shader->inited )
return shader;
else
return NULL;
}
shader_t *CShaderMng::GetNewShader( char *name )
{
shader_t *shader;
int i;
for( i = 0 ; i < m_numShaders ; i++ )
{
if( !stricmp( name , m_shaders[i].name ) )
return NULL;
}
shader = &m_shaders[ m_numShaders ];
shader->flags = 0;
shader->numPasses = 0;
shader->inited = false;
shader->frameFlag = 0;
strcpy( shader->name , name );
m_numShaders++;
return shader;
}
int CShaderMng::MakeDefaultShader( char *name )
{
shader_t *shader;
shader = &m_shaders[m_numShaders++];
strcpy( shader->name , name );
shader->flags = 0;
shader->numPasses = 2;
strcpy( shader->passes[0].map , name );
shader->passes[0].texRef = GetShaderTexRef( name );
shader->passes[0].flags = SHADERPASS_DEPTHWRITE | SHADERPASS_MAP;
shader->passes[0].depthFunc = D3DCMP_LESSEQUAL;
shader->passes[1].flags = SHADERPASS_MAP_LIGHTMAP | SHADERPASS_BLEND | SHADERPASS_NONDEPTHWRITE;
shader->passes[1].blend.src = D3DBLEND_DESTCOLOR;
shader->passes[1].blend.dest = D3DBLEND_ZERO;
shader->inited = true;
return m_numShaders - 1;
}
int CShaderMng::ReadShaderScript( char *fName , DWORD size , BYTE *data )
{
char *token;
shader_t *shader;
if( data )
{
if( !g_script.Load( fName , size , data ) )
return false;
}
else
{
if( !g_script.Load( fName ) )
return false;
}
g_script.BeginParse();
while(1)
{
token = g_script.GetNextToken( true );
if( !token[0] ) break;
shader = GetNewShader( token );
if( !shader )
{
g_script.SkipBracedSection();
continue;
}
token = g_script.GetNextToken( true );
if( token[0] != '{' )
return false;
while( 1 )
{
token = g_script.GetNextToken( true );
if( !token[0] ) break;
if (token[0] == '{')
{
ParseShaderPass( shader );
}
else if (token[0] == '}')
break;
else
ParseShaderToken( shader , token );
}
if( shader->flags & SHADER_SURF_TRANS )
shader->flags |= SHADER_CULL_NONE;
}
return true;
}
void CShaderMng::ParseShaderPass( shader_t *shader )
{
shaderpass_t *pass;
char *token;
pass = &shader->passes[ shader->numPasses ];
pass->flags = 0;
pass->texRef = -1;
pass->depthFunc = D3DCMP_LESSEQUAL;
pass->rgbGen.type = SHADERPASS_RGBGEN_IDENTITY;
pass->tcMod.numTcModFuncs = 0;
while(1)
{
token = g_script.GetNextToken( true );
if( !token[0] ) break;
if (token[0] == '}')
{
break;
}
else
{
ParseShaderPassToken( shader, pass, token );
}
}
if( ( pass->flags & SHADERPASS_NONDEPTHWRITE ) && ( pass->flags & SHADERPASS_DEPTHWRITE ) )
{
pass->flags &= ~SHADERPASS_NONDEPTHWRITE;
}
if( ( pass->flags & SHADERPASS_TCGEN ) )
{
shader->flags |= SHADER_TCGEN;
}
shader->numPasses++;
}
wavetype_t CShaderMng::ParseWaveFunc( char *param )
{
if( stricmp( param , "sin" ) ) return WAVE_SIN;
if( stricmp( param , "triangle" ) ) return WAVE_TRIANGLE;
if( stricmp( param , "square" ) ) return WAVE_SQUARE;
if( stricmp( param , "sawtooth" ) ) return WAVE_SAWTOOTH;
if( stricmp( param , "inversesawtooth" ) ) return WAVE_INVSAWTOOTH;
if( stricmp( param , "noise" ) ) return WAVE_NOISE;
return WAVE_NONE;
}
void CShaderMng::ShaderKeyFunc_skyparms( shader_t *shader )
{
char envTex[ GTH_MAX_SIZE_FILENAME ];
char *parameter;
envsky_t *envSky;
parameter = g_script.GetNextToken(false);
if( !parameter[0] )
{
return;
}
if( parameter[0] != '-' )
{
shader->flags |= SHADER_SKY_ENVIRON;
envSky = &m_envSkys[ m_numEnvSkys++ ];
strcpy( envTex , parameter );
strcat( envTex , "_up" );
strcpy( envSky->map[0] , envTex );
strcpy( envTex , parameter );
strcat( envTex , "_ft" );
strcpy( envSky->map[1] , envTex );
strcpy( envTex , parameter );
strcat( envTex , "_rt" );
strcpy( envSky->map[2] , envTex );
strcpy( envTex , parameter );
strcat( envTex , "_bk" );
strcpy( envSky->map[3] , envTex );
strcpy( envTex , parameter );
strcat( envTex , "_lf" );
strcpy( envSky->map[4] , envTex );
strcpy( envTex , parameter );
strcat( envTex , "_dn" );
strcpy( envSky->map[5] , envTex );
shader->envSky = envSky;
}
parameter = g_script.GetNextToken(false);
if( !parameter[0] )
{
return;
}
if( parameter[0] != '-' )
{
shader->skyheight = (float) atof( parameter );
}
else
{
shader->skyheight = 0.0f;
}
g_script.SkipLine();
}
void CShaderMng::ShaderKeyFunc_cull( shader_t *shader )
{
char *parameter;
parameter = g_script.GetNextToken( false );
if( !parameter[0] ) return;
if( !stricmp( parameter , "none" ) || !stricmp( parameter , "disable" ) || !stricmp( parameter , "twosided" ) )
{
shader->flags |= SHADER_CULL;
shader->flags |= SHADER_CULL_NONE;
}
else if( !stricmp( parameter , "back" ) || !stricmp( parameter , "backsided" ) )
{
shader->flags |= SHADER_CULL;
shader->flags |= SHADER_CULL_BACK;
}
else if( !stricmp( parameter , "front" ) )
{
shader->flags |= SHADER_CULL;
shader->flags |= SHADER_CULL_FRONT;
}
g_script.SkipLine();
}
void CShaderMng::ShaderKeyFunc_deformvertexes( shader_t *shader )
{
char parameter[10][32];
char *token;
int numParms = 0;
while( 1 )
{
token = g_script.GetNextToken( false );
if( !token[ 0 ] ) break;
strcpy( parameter[ numParms ] , token );
numParms++;
}
if(!stricmp( parameter[0] , "wave" ))
{
if( numParms < 7 )
return;
shader->deform.div = 1.0f / (float) atof( parameter[1] );
shader->deform.func.type = ParseWaveFunc( parameter[2] );
if( shader->deform.func.type == WAVE_NONE )
return;
shader->deform.func.base = (float)atof( parameter[3] );
shader->deform.func.amplitude = (float)atof( parameter[4] );
shader->deform.func.phase = (float)atof( parameter[5] );
shader->deform.func.frequency = (float)atof( parameter[6] );
shader->flags |= SHADER_DEFORMVERTEXES;
}
else if( !stricmp( parameter[0] , "normal" ) )
{
if( numParms < 6 )
return;
shader->deform.div = (float) atof( parameter[1] );
shader->deform.func.type = ParseWaveFunc( parameter[2] );
if( shader->deform.func.type == WAVE_NONE )
return;
shader->deform.func.base = (float) atof( parameter[3] );
shader->deform.func.amplitude = (float) atof( parameter[4] );
shader->deform.func.phase = 0.0f;
shader->deform.func.frequency = (float) atof( parameter[5] );
shader->flags |= SHADER_DEFORMVERTEXES;
}
else if( !stricmp( parameter[0] , "bulge" ) )
{
if(numParms < 4)
return;
}
else if( !stricmp( parameter[0] , "move" ) )
{
if( numParms < 9 )
return;
}
else if( !stricmp( parameter[0] , "autosprite" ) )
{
shader->flags |= SHADER_DEFORMVERT_AUTOSPRITE;
}
else if( !stricmp( parameter[0] , "autosprite2" ) )
{
shader->flags |= SHADER_DEFORMVERT_AUTOSPRITE2;
}
}
void CShaderMng::ShaderKeyFunc_sort( shader_t *shader )
{
char *parameter;
parameter = g_script.GetNextToken( false );
if( !parameter[0] ) return;
if ( !stricmp( parameter , "portal" ) || !stricmp( parameter , "1" ) )
{
shader->flags |= SHADER_SORT;
shader->flags |= SHADER_SORT_PORTAL;
}
else if( !stricmp( parameter , "sky" ) || !stricmp( parameter , "2" ) )
{
shader->flags |= SHADER_SORT;
shader->flags |= SHADER_SORT_SKY;
}
else if( !stricmp( parameter , "opaque" ) || !stricmp( parameter , "3" ) )
{
shader->flags |= SHADER_SORT;
shader->flags |= SHADER_SORT_OPAQUE;
}
else if( !stricmp( parameter , "banner" ) || !stricmp( parameter , "6" ) )
{
shader->flags |= SHADER_SORT;
shader->flags |= SHADER_SORT_BANNER;
}
else if( !stricmp( parameter , "underwater" ) || !stricmp( parameter , "8" ) )
{
shader->flags |= SHADER_SORT;
shader->flags |= SHADER_SORT_UNDERWATER;
}
else if( !stricmp( parameter , "additive" ) || !stricmp( parameter , "9" ) )
{
shader->flags |= SHADER_SORT;
shader->flags |= SHADER_SORT_ADDITIVE;
}
else if( !stricmp( parameter , "nearest" ) || !stricmp( parameter , "16" ) )
{
shader->flags |= SHADER_SORT;
shader->flags |= SHADER_SORT_NEAREST;
}
g_script.SkipLine();
}
void CShaderMng::ShaderKeyFunc_surfaceparm( shader_t *shader )
{
char *parameter;
parameter = g_script.GetNextToken( false );
if( !parameter[0] ) return;
if ( !stricmp( parameter , "trans" ) )
{
shader->flags |= SHADER_SURF;
shader->flags |= SHADER_SURF_TRANS;
}
else if( !stricmp( parameter , "sky" ) )
{
shader->flags |= SHADER_SURF | SHADER_SKY;
shader->flags |= SHADER_SURF_SKY;
}
else if( !stricmp( parameter , "nonsolid" ) )
{
shader->flags |= SHADER_SURF;
shader->flags |= SHADER_SURF_TRANS;
}
else if( !stricmp( parameter , "water" ) )
{
shader->flags |= SHADER_SURF;
shader->flags |= SHADER_SURF_TRANS;
}
else if( !stricmp( parameter , "nodraw" ) )
{
shader->flags |= SHADER_SURF;
shader->flags |= SHADER_SURF_NODRAW;
}
else if( !stricmp( parameter , "nolightmap" ) )
{
shader->flags |= SHADER_SURF;
shader->flags |= SHADER_SURF_NOLIGHTMAP;
}
g_script.SkipLine();
}
void CShaderMng::ParseShaderToken( shader_t *shader , char *token )
{
if ( !stricmp( token , "skyparms" ) )
{
ShaderKeyFunc_skyparms( shader );
}
else if( !stricmp( token , "cull" ) )
{
ShaderKeyFunc_cull( shader );
}
else if( !stricmp( token , "deformvertexes" ) )
{
ShaderKeyFunc_deformvertexes( shader );
}
else if( !stricmp( token , "fogparms" ) )
{
}
else if( !stricmp( token , "nopicmip" ) )
{
}
else if( !stricmp( token , "nomipmap" ) )
{
shader->flags |= SHADER_NOMIPMAPS;
}
else if( !stricmp( token , "polygonoffset" ) )
{
}
else if( !stricmp( token , "portal" ) )
{
}
else if( !stricmp( token , "sort" ) )
{
ShaderKeyFunc_sort( shader );
}
else if( !stricmp( token , "tesssize" ) )
{
}
else if( !stricmp( token , "surfaceparm" ) )
{
ShaderKeyFunc_surfaceparm( shader );
}
else
g_script.SkipLine();
}
void CShaderMng::ShaderPassKeyFunc_map( shader_t *shader , shaderpass_t *pass )
{
char *parameter;
parameter = g_script.GetNextToken( false );
if( !parameter[0] ) return;
if ( !stricmp( parameter , "$lightmap" ) )
pass->flags |= SHADERPASS_MAP_LIGHTMAP;
else if( !stricmp( parameter , "$whiteimage" ) )
pass->flags |= SHADERPASS_MAP_WHITEIMAGE;
else
{
pass->flags |= SHADERPASS_MAP;
strcpy( pass->map , parameter );
}
g_script.SkipLine();
}
void CShaderMng::ShaderPassKeyFunc_clampmap( shader_t *shader , shaderpass_t *pass )
{
char *parameter;
parameter = g_script.GetNextToken( false );
if( !parameter[0] ) return;
pass->flags |= SHADERPASS_MAP | SHADERPASS_CLAMPMAP;
strcpy( pass->map , parameter );
g_script.SkipLine();
}
void CShaderMng::ShaderPassKeyFunc_animmap( shader_t *shader , shaderpass_t *pass )
{
char parameter[20][ GTH_MAX_SIZE_FILENAME ];
char *token;
anim_t *anim;
int numParms = 0;
while( 1 )
{
token = g_script.GetNextToken( false );
if( !token[ 0 ] ) break;
strcpy( parameter[ numParms ] , token );
numParms++;
}
pass->flags |= SHADERPASS_MAP_ANIMMAP;
anim = &m_animMaps[ m_numAnimMaps++ ];
anim->fps = (float) atof( parameter[0] );
anim->numFrames = numParms - 1;
for ( int i = 0 ; i < numParms - 1 ; ++i )
strcpy( anim->maps[i] , parameter[ i + 1 ] );
pass->animMap = anim;
}
void CShaderMng::ShaderPassKeyFunc_blendfunc( shader_t *shader , shaderpass_t *pass )
{
char parameter[10][32];
char *token;
int numParms = 0;
while( 1 )
{
token = g_script.GetNextToken( false );
if( !token[ 0 ] ) break;
strcpy( parameter[ numParms ] , token );
numParms++;
}
if( numParms == 1 )
{
if( !stricmp( parameter[0] , "blend" ) )
{
pass->blend.src = D3DBLEND_SRCALPHA;
pass->blend.dest = D3DBLEND_INVSRCALPHA;
}
else if( !stricmp( parameter[0] , "filter" ) )
{
pass->blend.src = D3DBLEND_ZERO;
pass->blend.dest = D3DBLEND_SRCCOLOR;
}
else if( !stricmp(parameter[0] , "add" ) )
{
pass->blend.src = pass->blend.dest = D3DBLEND_ONE;
}
else
return;
}
else if( numParms == 2 )
{
for( int i = 0 ; i < 2 ; ++i )
{
int *blend = ( i == 0 ) ? &pass->blend.src : &pass->blend.dest;
if ( !stricmp( parameter[i] , "gl_zero" ) )
*blend = D3DBLEND_ZERO;
else if( !stricmp( parameter[i] , "gl_one" ) )
*blend = D3DBLEND_ONE;
else if( !stricmp( parameter[i] , "gl_src_color" ) )
*blend = D3DBLEND_SRCCOLOR;
else if( !stricmp( parameter[i] , "gl_src_alpha" ) )
*blend = D3DBLEND_SRCALPHA;
else if( !stricmp( parameter[i] , "gl_dst_color" ) )
*blend = D3DBLEND_DESTCOLOR;
else if( !stricmp( parameter[i] , "gl_dst_alpha" ) )
*blend = D3DBLEND_DESTALPHA;
else if( !stricmp( parameter[i] , "gl_one_minus_src_color" ) )
*blend = D3DBLEND_INVSRCCOLOR;
else if( !stricmp( parameter[i] , "gl_one_minus_src_alpha" ) )
*blend = D3DBLEND_INVSRCALPHA;
else if( !stricmp( parameter[i] , "gl_one_minus_dst_color" ) )
*blend = D3DBLEND_INVDESTCOLOR;
else if( !stricmp( parameter[i] , "gl_one_minus_dst_alpha" ) )
*blend = D3DBLEND_INVDESTALPHA;
else
return;
}
}
if( pass->blend.src == D3DBLEND_ONE && pass->blend.dest == D3DBLEND_ZERO )
return;
pass->flags |= SHADERPASS_BLEND | SHADERPASS_NONDEPTHWRITE;
}
void CShaderMng::ShaderPassKeyFunc_rgbgen( shader_t *shader , shaderpass_t *pass )
{
char parameter[10][32];
char *token;
int numParms = 0;
while( 1 )
{
token = g_script.GetNextToken( false );
if( !token[ 0 ] ) break;
strcpy( parameter[ numParms ] , token );
numParms++;
}
if ( !stricmp( parameter[0] , "wave" ) )
{
if( numParms < 6 ) return;
pass->rgbGen.func.type = ParseWaveFunc( parameter[1] );
if( pass->rgbGen.func.type == WAVE_NONE ) return;
pass->rgbGen.func.base = (float) atof( parameter[2] );
pass->rgbGen.func.amplitude = (float) atof( parameter[3] );
pass->rgbGen.func.phase = (float) atof( parameter[4] );
pass->rgbGen.func.frequency = (float) atof( parameter[5] );
pass->rgbGen.type = SHADERPASS_RGBGEN_WAVE;
pass->flags |= SHADERPASS_RGBGEN;
}
else if( !stricmp( parameter[0] , "identity" ) || !stricmp( parameter[0] , "identitylighting" ) )
{
pass->rgbGen.type = SHADERPASS_RGBGEN_IDENTITY;
pass->flags |= SHADERPASS_RGBGEN;
}
else if( !stricmp( parameter[0] , "vertex" ) || !stricmp( parameter[0] , "exactvertex" ) )
{
pass->rgbGen.type = SHADERPASS_RGBGEN_VERTEX;
pass->flags |= SHADERPASS_RGBGEN;
}
}
void CShaderMng::ShaderPassKeyFunc_alphagen( shader_t *shader , shaderpass_t *pass )
{
char parameter[10][32];
char *token;
int numParms = 0;
while( 1 )
{
token = g_script.GetNextToken( false );
if( !token[ 0 ] ) break;
strcpy( parameter[ numParms ] , token );
numParms++;
}
if ( !stricmp( parameter[0] , "wave" ) )
{
if( numParms < 6 ) return;
pass->alphaGen.func.type = ParseWaveFunc( parameter[1] );
if( pass->alphaGen.func.type == WAVE_NONE ) return;
pass->alphaGen.func.base = (float) atof( parameter[2] );
pass->alphaGen.func.amplitude = (float) atof( parameter[3] );
pass->alphaGen.func.phase = (float) atof( parameter[4] );
pass->alphaGen.func.frequency = (float) atof( parameter[5] );
pass->alphaGen.type = SHADERPASS_RGBGEN_WAVE;
pass->flags |= SHADERPASS_ALPHAGEN;
}
else if( !stricmp( parameter[0] , "identity" ) || !stricmp( parameter[0] , "identitylighting" ) )
{
pass->alphaGen.type = SHADERPASS_RGBGEN_IDENTITY;
pass->flags |= SHADERPASS_ALPHAGEN;
}
else if( !stricmp( parameter[0] , "vertex" ) || !stricmp( parameter[0] , "exactvertex" ) )
{
pass->alphaGen.type = SHADERPASS_RGBGEN_VERTEX;
pass->flags |= SHADERPASS_ALPHAGEN;
}
}
void CShaderMng::ShaderPassKeyFunc_tcgen( shader_t *shader , shaderpass_t *pass )
{
char *parameter;
parameter = g_script.GetNextToken( false );
if( !parameter[0] ) return;
if ( !stricmp( parameter , "base" ) )
pass->tcGen = SHADERPASS_TCGEN_BASE;
else if( !stricmp( parameter , "lightmap" ) )
{
pass->tcGen = SHADERPASS_TCGEN_LIGHTMAP;
}
else if( !stricmp( parameter , "environment" ) )
{
pass->tcGen = SHADERPASS_TCGEN_ENVIRONMENT;
pass->flags |= SHADERPASS_TCGEN;
}
else if( !stricmp( parameter , "vector" ) )
{
}
g_script.SkipLine();
}
void CShaderMng::ShaderPassKeyFunc_depthfunc( shader_t *shader , shaderpass_t *pass )
{
char *parameter;
parameter = g_script.GetNextToken( false );
if( !parameter[0] ) return;
if ( !stricmp( parameter , "equal" ) )
pass->depthFunc = D3DCMP_EQUAL;
else if( !stricmp( parameter , "less" ) )
pass->depthFunc = D3DCMP_LESS;
else if( !stricmp( parameter , "greater" ) )
pass->depthFunc = D3DCMP_GREATER;
else if( !stricmp( parameter , "lequal" ) )
pass->depthFunc = D3DCMP_LESSEQUAL;
else if( !stricmp( parameter , "gequal" ) )
pass->depthFunc = D3DCMP_GREATEREQUAL;
else if( !stricmp( parameter , "notequal" ) )
pass->depthFunc = D3DCMP_NOTEQUAL;
pass->flags |= SHADERPASS_DEPTHFUNC;
g_script.SkipLine();
}
void CShaderMng::ShaderPassKeyFunc_alphafunc( shader_t *shader , shaderpass_t *pass )
{
char *parameter;
parameter = g_script.GetNextToken( false );
if( !parameter[0] ) return;
if ( !stricmp( parameter , "ge128" ) )
{
pass->alphaFunc.func = D3DCMP_GREATEREQUAL;
pass->alphaFunc.ref = 128;
}
else if( !stricmp( parameter , "lt128" ) )
{
pass->alphaFunc.func = D3DCMP_LESS;
pass->alphaFunc.ref = 128;
}
else if( !stricmp( parameter , "gt0" ) )
{
pass->alphaFunc.func = D3DCMP_GREATER;
pass->alphaFunc.ref = 0;
}
pass->flags |= SHADERPASS_ALPHAFUNC | SHADERPASS_NONDEPTHWRITE;
g_script.SkipLine();
}
void CShaderMng::ShaderPassKeyFunc_tcmod( shader_t *shader , shaderpass_t *pass )
{
char parameter[10][32];
char *token;
int numParms = 0;
while( 1 )
{
token = g_script.GetNextToken( false );
if( !token[ 0 ] ) break;
strcpy( parameter[ numParms ] , token );
numParms++;
}
if( pass->tcMod.numTcModFuncs >= MAX_SHADER_TCMOD ) return;
tcmodfunc_t *tcModeFunc = &pass->tcMod.tcModFuncs[ pass->tcMod.numTcModFuncs ];
if ( !stricmp( parameter[0] , "rotate" ) )
{
if( numParms < 2 ) return;
tcModeFunc->type = TCMOD_ROTATE;
tcModeFunc->params[0] = (float) atof( parameter[1] );
pass->tcMod.numTcModFuncs++;
pass->flags |= SHADERPASS_TCMOD;
}
else if( !stricmp( parameter[0] , "scale" ) )
{
if( numParms < 3 ) return;
tcModeFunc->type = TCMOD_SCALE;
tcModeFunc->params[0] = (float) atof( parameter[1] );
tcModeFunc->params[1] = (float) atof( parameter[2] );
pass->tcMod.numTcModFuncs++;
pass->flags |= SHADERPASS_TCMOD;
}
else if( !stricmp( parameter[0] , "scroll" ) )
{
if( numParms < 3 ) return;
tcModeFunc->type = TCMOD_SCROLL;
tcModeFunc->params[0] = (float) atof( parameter[1] );
tcModeFunc->params[1] = (float) atof( parameter[2] );
pass->tcMod.numTcModFuncs++;
pass->flags |= SHADERPASS_TCMOD;
}
else if( !stricmp( parameter[0] , "stretch" ) )
{
if( numParms < 6 ) return;
tcModeFunc->type = TCMOD_STRETCH;
tcModeFunc->func.type = ParseWaveFunc( parameter[1] );
if( tcModeFunc->func.type == WAVE_NONE ) return;
tcModeFunc->func.base = (float) atof( parameter[2] );
tcModeFunc->func.amplitude = (float) atof( parameter[3] );
tcModeFunc->func.phase = (float) atof( parameter[4] );
tcModeFunc->func.frequency = (float) atof( parameter[5] );
pass->tcMod.numTcModFuncs++;
pass->flags |= SHADERPASS_TCMOD;
}
else if( !stricmp( parameter[0] , "turb" ) )
{
if( numParms < 5 ) return;
tcModeFunc->type = TCMOD_TURB;
tcModeFunc->func.type = WAVE_NONE;
tcModeFunc->func.base = 1.0f;
tcModeFunc->func.amplitude = (float) atof( parameter[2] );
tcModeFunc->func.phase = (float) atof( parameter[3] );
tcModeFunc->func.frequency = (float) atof( parameter[4] );
pass->tcMod.numTcModFuncs++;
pass->flags |= SHADERPASS_TCMOD;
}
}
void CShaderMng::ParseShaderPassToken( shader_t *shader , shaderpass_t *pass , char *token )
{
if ( !stricmp( token , "map" ) )
{
ShaderPassKeyFunc_map( shader , pass );
}
else if( !stricmp( token , "clampmap" ) )
{
ShaderPassKeyFunc_clampmap( shader , pass );
}
else if( !stricmp( token , "animmap" ) )
{
ShaderPassKeyFunc_animmap( shader , pass );
}
else if( !stricmp( token , "blendfunc" ) )
{
ShaderPassKeyFunc_blendfunc( shader , pass );
}
else if( !stricmp( token , "rgbgen" ) )
{
ShaderPassKeyFunc_rgbgen( shader , pass );
}
else if( !stricmp( token , "alphagen" ) )
{
ShaderPassKeyFunc_alphagen( shader , pass );
}
else if( !stricmp( token , "tcgen" ) )
{
ShaderPassKeyFunc_tcgen( shader , pass );
}
else if( !stricmp( token , "tcmod" ) )
{
ShaderPassKeyFunc_tcmod( shader , pass );
}
else if( !stricmp( token , "depthfunc" ) )
{
ShaderPassKeyFunc_depthfunc( shader , pass );
}
else if( !stricmp( token , "depthwrite" ) )
{
pass->flags |= SHADERPASS_DEPTHWRITE;
}
else if( !stricmp( token , "detail" ) )
{
pass->blend.src = D3DBLEND_DESTCOLOR;
pass->blend.dest = D3DBLEND_SRCCOLOR;
pass->flags |= SHADERPASS_BLEND;
}
else if( !stricmp( token , "alphafunc" ) )
{
ShaderPassKeyFunc_alphafunc( shader , pass );
}
else
g_script.SkipLine();
}
void CShaderMng::EvaluateTcMod( shaderpass_t *pass , float time )
{
tcmod_t *tcMod = &pass->tcMod;
matrix4x4_t mat;
mat.Translate( 0.5f , 0.5f , 0.0f );
for( int i = 0 ; i < tcMod->numTcModFuncs ; i++ )
{
EvaluateTcModFunc( &tcMod->tcModFuncs[i] , time );
mat *= tcMod->tcModFuncs[i].mat;
}
mat.Translate( -0.5f , -0.5f , 0.0f );
tcMod->tcMatrix = mat;
tcMod->tcMatrix.zx = tcMod->tcMatrix.wx;
tcMod->tcMatrix.zy = tcMod->tcMatrix.wy;
}
void CShaderMng::EvaluateTcModFunc( tcmodfunc_t *tcmodFunc, float asyncTime )
{
tcmodFunc->mat.Identity();
switch( tcmodFunc->type ) {
case TCMOD_ROTATE:
tcmodFunc->mat.RotateZ( tcmodFunc->params[0] * asyncTime );
break;
case TCMOD_SCALE:
tcmodFunc->mat.Scale( tcmodFunc->params[0] , tcmodFunc->params[1] , 1.0f );
break;
case TCMOD_SCROLL:
tcmodFunc->mat.Translate( tcmodFunc->params[0] * asyncTime , tcmodFunc->params[1] * asyncTime , 0 );
break;
case TCMOD_STRETCH: {
float f = EvaluateFunc( &tcmodFunc->func , asyncTime );
tcmodFunc->mat.Scale( f , f , 1.0f );
}
break;
case TCMOD_TURB: {
float x = ( tcmodFunc->func.phase + asyncTime ) * tcmodFunc->func.frequency;
x -= (float) floor(x);
float y1,y2;
y1 = (float) sin( x * __TWOPI ) * tcmodFunc->func.amplitude + tcmodFunc->func.base;
y2 = (float) sin( ( x + 0.25 ) * __TWOPI ) * tcmodFunc->func.amplitude + tcmodFunc->func.base;
tcmodFunc->mat.Scale( y1 , y2 , 1.0f );
}
break;
case TCMOD_TRANSFORM:
break;
}
}
float CShaderMng::EvaluateFunc( wavefunc_t *func, float asyncTime )
{
float x, y;
switch( func->type )
{
case WAVE_SIN:
x = asyncTime * func->frequency + func->phase;
x = (float)sin( x * __TWOPI );
y = func->base + ( func->amplitude * x );
break;
case WAVE_TRIANGLE:
x = (float)fmod( asyncTime + ( func->phase / func->frequency ) , 1 / func->frequency ) * func->frequency;
x *= 2.0f;
if ( x > 1.0f )
x = 2.0f - x;
x -= 0.5f;
x *= 2.0f;
y = func->base + ( func->amplitude * x );
break;
case WAVE_SQUARE:
x = (float)fmod( asyncTime + ( func->phase / func->frequency ) , 1 / func->frequency ) * func->frequency;
if ( x > 0.5f )
x = 1.0f;
else
x = -1.0f;
y = func->base + ( func->amplitude * x );
break;
case WAVE_SAWTOOTH:
x = (float)fmod( asyncTime + ( func->phase / func->frequency ) , 1 / func->frequency ) * func->frequency;
y = func->base + ( func->amplitude * x );
break;
case WAVE_INVSAWTOOTH:
x = (float)fmod( asyncTime + ( func->phase / func->frequency ) , 1 / func->frequency ) * func->frequency;
x = func->base + ( func->amplitude * x );
y = 1.0f - x;
break;
default :
return 0.0f;
}
return y;
}
float CShaderMng::EvaluateFunc( wavefunc_t *func , float offset , float asyncTime )
{
float x, y;
switch( func->type )
{
case WAVE_SIN:
x = asyncTime * func->frequency + func->phase + offset;
x = (float)sin( x * __TWOPI );
y = func->base + ( func->amplitude * x );
break;
case WAVE_TRIANGLE:
x = (float)fmod( asyncTime + ( ( func->phase + offset ) / func->frequency ) , 1 / func->frequency ) * func->frequency;
x *= 2.0f;
if ( x > 1.0f )
x = 2.0f - x;
x -= 0.5f;
x *= 2.0f;
y = func->base + ( func->amplitude * x );
break;
case WAVE_SQUARE:
x = (float)fmod( asyncTime + ( ( func->phase + offset ) / func->frequency ) , 1 / func->frequency ) * func->frequency;
if ( x > 0.5f )
x = 1.0f;
else
x = -1.0f;
y = func->base + ( func->amplitude * x );
break;
case WAVE_SAWTOOTH:
x = (float)fmod( asyncTime + ( ( func->phase + offset ) / func->frequency ) , 1 / func->frequency ) * func->frequency;
y = func->base + ( func->amplitude * x );
break;
case WAVE_INVSAWTOOTH:
x = (float)fmod( asyncTime + ( ( func->phase + offset ) / func->frequency ) , 1 / func->frequency ) * func->frequency;
x = func->base + ( func->amplitude * x );
y = 1.0f - x;
break;
default :
return 0.0f;
}
return y;
}
void CShaderMng::PrepareShader( int idxShader , DWORD frameFlag )
{
shaderpass_t *pass;
DWORD flags;
DWORD genRGBColor = 0x00000000;
DWORD genAlphaColor;
float color;
int i;
shader_t *shader;
shader = &m_shaders[ idxShader ];
if( shader->frameFlag == frameFlag ) return;
shader->frameFlag = frameFlag;
pass = &shader->passes[0];
for( i = 0 ; i < shader->numPasses ; i++ , pass++ )
{
flags = pass->flags;
if( flags & SHADERPASS_MAP ){;}
else if( flags & SHADERPASS_MAP_LIGHTMAP )
{
pass->texRef = g_texMng.GetWhiteImageRef();
}
else if( flags & SHADERPASS_MAP_ANIMMAP )
{
pass->texRef = pass->animMap->GetFrame( g_timer.GetAppTime() );
}
else if( flags & SHADERPASS_MAP_WHITEIMAGE )
{
pass->texRef = g_texMng.GetWhiteImageRef();
}
if( flags & SHADERPASS_RGBGEN )
{
if( pass->rgbGen.type == SHADERPASS_RGBGEN_WAVE )
{
color = EvaluateFunc( &pass->rgbGen.func , g_timer.GetAppTime() );
color *= 255.0f;
if( color < 0.0f ) color = 0.0f;
else if( color > 255.0f ) color = 255.0f;
genRGBColor = (DWORD) color;
pass->rgbGen.color = MAKE_COLOR_ARGB( 0xFF , genRGBColor , genRGBColor , genRGBColor );
}
else if( pass->rgbGen.type == SHADERPASS_RGBGEN_IDENTITY )
pass->rgbGen.color = MAKE_COLOR_ARGB( 0xFF , 0xFF , 0xFF , 0xFF );
}
if( flags & SHADERPASS_ALPHAGEN )
{
if( pass->alphaGen.type == SHADERPASS_RGBGEN_WAVE )
{
color = EvaluateFunc( &pass->alphaGen.func , g_timer.GetAppTime() );
color *= 255.0f;
if( color < 0.0f ) color = 0.0f;
else if( color > 255.0f ) color = 255.0f;
genAlphaColor = (DWORD) color;
pass->alphaGen.color = MAKE_COLOR_ARGB( genAlphaColor , genRGBColor , genRGBColor , genRGBColor );
}
else if( pass->alphaGen.type == SHADERPASS_RGBGEN_IDENTITY )
pass->alphaGen.color = MAKE_COLOR_ARGB( 0xFF , 0xFF , 0xFF , 0xFF );
}
if( flags & SHADERPASS_TCMOD )
EvaluateTcMod( pass , g_timer.GetAppTime() );
}
}
void CShaderMng::PrepareShader( int idxShader , float time )
{
shaderpass_t *pass;
DWORD flags;
DWORD genRGBColor = 0x00000000;
DWORD genAlphaColor;
float color;
int i;
shader_t *shader;
shader = &m_shaders[ idxShader ];
shader->frameFlag -= 1;
pass = &shader->passes[0];
for( i = 0 ; i < shader->numPasses ; i++ , pass++ )
{
flags = pass->flags;
if( flags & SHADERPASS_MAP ){;}
else if( flags & SHADERPASS_MAP_LIGHTMAP )
{
pass->texRef = g_texMng.GetWhiteImageRef();
}
else if( flags & SHADERPASS_MAP_ANIMMAP )
{
pass->texRef = pass->animMap->GetFrame( time );
}
else if( flags & SHADERPASS_MAP_WHITEIMAGE )
{
pass->texRef = g_texMng.GetWhiteImageRef();
}
if( flags & SHADERPASS_RGBGEN )
{
if( pass->rgbGen.type == SHADERPASS_RGBGEN_WAVE )
{
color = EvaluateFunc( &pass->rgbGen.func , time );
color *= 255.0f;
if( color < 0.0f ) color = 0.0f;
else if( color > 255.0f ) color = 255.0f;
genRGBColor = (DWORD) color;
pass->rgbGen.color = MAKE_COLOR_ARGB( 0xFF , genRGBColor , genRGBColor , genRGBColor );
}
else if( pass->rgbGen.type == SHADERPASS_RGBGEN_IDENTITY )
pass->rgbGen.color = MAKE_COLOR_ARGB( 0xFF , 0xFF , 0xFF , 0xFF );
}
if( flags & SHADERPASS_ALPHAGEN )
{
if( pass->alphaGen.type == SHADERPASS_RGBGEN_WAVE )
{
color = EvaluateFunc( &pass->alphaGen.func , time );
color *= 255.0f;
if( color < 0.0f ) color = 0.0f;
else if( color > 255.0f ) color = 255.0f;
genAlphaColor = (DWORD) color;
pass->alphaGen.color = MAKE_COLOR_ARGB( genAlphaColor , genRGBColor , genRGBColor , genRGBColor );
}
else if( pass->alphaGen.type == SHADERPASS_RGBGEN_IDENTITY )
pass->alphaGen.color = MAKE_COLOR_ARGB( 0xFF , 0xFF , 0xFF , 0xFF );
}
if( flags & SHADERPASS_TCMOD )
EvaluateTcMod( pass , time );
}
}
#define TCGEN_EFFECTIVE_DISTANCE ( 500.0f * 500.0f )
void CShaderMng::PrepareTCGen( shader_t *shader , vec3_t pos )
{
vec3_t diff;
float dist , ratio;
shader->tcGenMatrix.Identity();
VectorSubtract( diff, pos, g_camera.m_position );
dist = VectorDotProduct( diff , diff );
ratio = dist / TCGEN_EFFECTIVE_DISTANCE;
if ( ratio > 10.0f ) ratio = 1.9f;
else if( ratio > 1.0f ) ratio = 0.9f + ratio * 0.1f;
else if( ratio > 0.3f ) ratio = 0.12f + ratio * 0.6f;
else if( ratio < 0.3f ) ratio = 0.3f;
shader->tcGenMatrix.xx = ratio;
shader->tcGenMatrix.yy = ratio;
shader->tcGenMatrix.zx -= g_camera.m_angles[ YAW ] / 360.0f;
shader->tcGenMatrix.zy -= g_camera.m_angles[ PITCH ] / 180.0f;
} | C++ |
#include "ResManager.h"
#include <queue>
using namespace std;
void BaseResource::Clear()
{
m_Priority = RES_MED_PRIORITY;
m_nRefCount = 0;
m_LastAccess = 0;
}
bool BaseResource::operator < ( BaseResource& container )
{
if( GetPriority() < container.GetPriority() ) return true;
else if( GetPriority() > container.GetPriority() ) return false;
else
{
if( m_LastAccess < container.GetLastAccess() ) return true;
else if( m_LastAccess > container.GetLastAccess() ) return false;
else
{
if( GetSize() < container.GetSize() ) return true;
else return false;
}
}
return false;
}
CResManager::CResManager()
{
Clear();
}
CResManager::~CResManager()
{
}
void CResManager::Clear()
{
m_ResourceMap.clear();
m_rhNextResHandle = INVALID_RHANDLE;
m_nCurrentUsedMemory = 0;
m_nMaximumMemory = 0;
m_bResourceReserved = false;
m_CurrentResource = m_ResourceMap.end();
}
bool CResManager::Create( unsigned int nMaxSize )
{
Clear();
SetMaximumMemory( nMaxSize );
return true;
}
void CResManager::Destroy()
{
for( ResMapItor itor = m_ResourceMap.begin(); itor != m_ResourceMap.end(); ++itor )
{
if( ((*itor).second) == NULL ) continue;
if( !((*itor).second)->IsLocked() )
{
delete ((*itor).second);
}
}
m_ResourceMap.clear();
Clear();
}
bool CResManager::SetMaximumMemory( size_t nMem )
{
m_nMaximumMemory = nMem;
return CheckForOverallocation();
}
bool CResManager::ReserveMemory( size_t nMem )
{
AddMemory( nMem );
if( !CheckForOverallocation() ) return false;
m_bResourceReserved = true;
return true;
}
bool CResManager::InsertResource( RHANDLE* rhUniqueID, BaseResource* pResource )
{
*rhUniqueID = GetNextResHandle();
m_ResourceMap.insert( ResMapPair( *rhUniqueID, pResource ) );
if( !m_bResourceReserved )
{
AddMemory( pResource->GetSize() );
if( !CheckForOverallocation() ) return false;
}
else m_bResourceReserved = false;
return true;
}
bool CResManager::InsertResource( RHANDLE rhUniqueID, BaseResource* pResource )
{
ResMapItor itor = m_ResourceMap.find( rhUniqueID );
if( itor != m_ResourceMap.end() ) return false;
m_ResourceMap.insert( ResMapPair( rhUniqueID, pResource ) );
if( !m_bResourceReserved )
{
AddMemory( pResource->GetSize() );
if( !CheckForOverallocation() ) return false;
}
else m_bResourceReserved = false;
return true;
}
bool CResManager::RegisterResource( RHANDLE rhUniqueID, BaseResource* pResource )
{
ResMapItor itor = m_ResourceMap.find( rhUniqueID );
if( itor != m_ResourceMap.end() ) return false;
m_ResourceMap.insert( ResMapPair( rhUniqueID, pResource ) );
return true;
}
bool CResManager::RemoveResource( RHANDLE rhUniqueID )
{
ResMapItor itor = m_ResourceMap.find( rhUniqueID );
if( itor == m_ResourceMap.end() ) return false;
if( ((*itor).second)->IsLocked() ) return false;
RemoveMemory( ((*itor).second)->GetSize() );
m_ResourceMap.erase( itor );
return true;
}
bool CResManager::RemoveResource( BaseResource* pResource )
{
ResMapItor itor;
for( itor = m_ResourceMap.begin(); itor != m_ResourceMap.end(); ++itor )
{
if(itor->second == pResource) break;
}
if( itor == m_ResourceMap.end() ) return false;
if( itor->second->IsLocked() ) return false;
RemoveMemory( pResource->GetSize() );
m_ResourceMap.erase( itor );
return true;
}
bool CResManager::DestroyResource( BaseResource* pResource )
{
if( !RemoveResource( pResource ) ) return false;
delete pResource;
return true;
}
bool CResManager::DestroyResource( RHANDLE rhUniqueID )
{
BaseResource* pResource = GetResource( rhUniqueID );
if( !RemoveResource(rhUniqueID ) ) return false;
delete pResource;
return true;
}
BaseResource* CResManager::GetResource( RHANDLE rhUniqueID )
{
ResMapItor itor = m_ResourceMap.find( rhUniqueID );
bool bGetSuccess = true;
if( itor == m_ResourceMap.end() )
return NULL;
itor->second->SetLastAccess( time(0) );
if( itor->second->IsDisposed() )
{
itor->second->Recreate();
AddMemory( itor->second->GetSize() );
Lock( rhUniqueID );
bGetSuccess = CheckForOverallocation();
Unlock( rhUniqueID );
}
if( !bGetSuccess ) return NULL;
return itor->second;
}
BaseResource* CResManager::Lock( RHANDLE rhUniqueID )
{
ResMapItor itor = m_ResourceMap.find( rhUniqueID );
if( itor == m_ResourceMap.end() ) return NULL;
itor->second->SetReferenceCount( itor->second->GetReferenceCount() + 1 );
if( itor->second->IsDisposed() )
{
itor->second->Recreate();
AddMemory( itor->second->GetSize() );
CheckForOverallocation();
}
return itor->second;
}
int CResManager::Unlock( RHANDLE rhUniqueID )
{
ResMapItor itor = m_ResourceMap.find( rhUniqueID );
if( itor == m_ResourceMap.end() ) return -1;
if( itor->second->GetReferenceCount() > 0 )
itor->second->SetReferenceCount( itor->second->GetReferenceCount() - 1 );
return itor->second->GetReferenceCount();
}
int CResManager::Unlock( BaseResource* pResource )
{
RHANDLE rhResource = FindResourceHandle( pResource );
if IS_INVALID_RHANDLE(rhResource)
return -1;
return Unlock(rhResource);
}
RHANDLE CResManager::FindResourceHandle( BaseResource* pResource )
{
ResMapItor itor;
for( itor = m_ResourceMap.begin(); itor != m_ResourceMap.end(); ++itor )
{
if( itor->second == pResource )
break;
}
if( itor == m_ResourceMap.end() )
return INVALID_RHANDLE;
return itor->first;
}
bool CResManager::CheckForOverallocation()
{
if( m_nCurrentUsedMemory > m_nMaximumMemory )
{
int iMemToPurge = m_nCurrentUsedMemory - m_nMaximumMemory;
priority_queue<BaseResource*, vector<BaseResource*>, ptr_greater<BaseResource*> > PriQueue;
for( ResMapItor itor = m_ResourceMap.begin(); itor != m_ResourceMap.end(); ++itor )
{
if( !itor->second->IsDisposed() && !itor->second->IsLocked() )
PriQueue.push( itor->second );
}
while( ( !PriQueue.empty() ) && ( m_nCurrentUsedMemory > m_nMaximumMemory ) )
{
unsigned int nDisposalSize = PriQueue.top()->GetSize();
PriQueue.top()->Dispose();
if( PriQueue.top()->IsDisposed() ) RemoveMemory(nDisposalSize);
PriQueue.pop();
}
if( PriQueue.empty() && ( m_nCurrentUsedMemory > m_nMaximumMemory ) )
return false;
}
return true;
}
| C++ |
#include "resourcecounter.h"
#include <string.h>
#include <STDIO.H>
#include <ASSERT.H>
#include <WINDOWS.H>
CResCounter *g_resCounter;
char *RES_DATATYPE_TEXT[] =
{
"Texture: Model - Map",
"Texture: Model - Lightmap",
"Texture: Model - Others",
"Texture: Character - PC",
"Texture: Character - NPC",
"Texture: Character - Monster",
"Texture: Interface",
"Mesh: Model - Map",
"Mesh: Model - Item",
"Mesh: Model - Effect",
"Mesh: Character - PC",
"Mesh: Character - NPC",
"Mesh: Character - Monster",
"Anim: Character - PC",
"Anim: Character - NPC",
"Anim: Character - Monster",
"Character: Character Manager",
"Character: Animation Manager",
"Character: Item Manager",
"Character: Skin Manager",
"Character: Aura Renderer",
"Character: Item Renderer",
"Character: Skin Renderer",
"Skel:",
"Etcs:",
};
char *RES_MEMTYPE_TEXT[] =
{
"Vertex Buffer - Default",
"Vertex Buffer - Managed",
"Index Buffer - Default",
"Index Buffer - Managed",
"Texture - Default",
"Texture - Managed",
};
CResCounter::CResCounter ()
{
Clear();
m_enabledState = false;
m_lockedState = false;
}
CResCounter::~CResCounter ()
{
}
void CResCounter::Clear ()
{
memset( m_sizeDataType, 0, sizeof(m_sizeDataType) );
memset( m_sizeMemType, 0, sizeof(m_sizeMemType) );
m_dataCount = 0;
m_memCount = 0;
}
void CResCounter::Reset_DataType ( int in_dataType )
{
if ( ! m_enabledState ) return;
m_sizeDataType[ in_dataType ] = 0;
}
void CResCounter::Reset_MemoryType ( int in_memType )
{
if ( ! m_enabledState ) return;
m_sizeMemType[ in_memType ] = 0;
}
int CResCounter::Add_DataType ( int in_dataType,
int in_size )
{
if ( ! m_enabledState ) return true;
assert( in_size >= 0 );
m_sizeDataType[ in_dataType ] += in_size;
++m_dataCount;
return true;
}
int CResCounter::Add_MemoryType ( int in_memType,
int in_size )
{
if ( ! m_enabledState ) return true;
assert( in_size >= 0 );
m_sizeMemType[ in_memType ] += in_size;
++m_memCount;
return true;
}
int CResCounter::PrintOut ()
{
if ( ! m_enabledState ) return true;
FILE *fp;
char filename[ 256 ];
int totalSize = 0;
SYSTEMTIME systemTime;
GetSystemTime( &systemTime );
sprintf( filename, "resource_usage_%02d_%02d_%02d_%02d_%02d_%02d.log", systemTime.wYear, systemTime.wMonth, systemTime.wDay, systemTime.wHour, systemTime.wMinute, systemTime.wSecond );
char *found = filename;
while ( found = strchr( found, ':' ) )
{
*found = '_';
found++;
}
fp = fopen( filename, "wt" );
int index;
for ( index = 0; \
index < RES_DATATYPE_NUM; \
++index )
{
fprintf( fp, "%-30s : %12d\n", RES_DATATYPE_TEXT[ index ], m_sizeDataType[ index ] );
totalSize += m_sizeDataType[ index ];
}
for ( index = 0; \
index < RES_MEMTYPE_NUM; \
++index )
{
fprintf( fp, "%-30s : %12d\n", RES_MEMTYPE_TEXT[ index ], m_sizeMemType[ index ] );
totalSize += m_sizeMemType[ index ];
}
fprintf( fp, "\nTotal Size : %d bytes", totalSize );
fclose( fp );
return true;
}
void CResCounter::LockResCounter ()
{
if ( m_lockedState ) return;
m_lockedState = true;
}
void CResCounter::EnableResCounter ()
{
if ( m_lockedState ) return;
m_enabledState = true;
}
void CResCounter::DisableResCounter ()
{
if ( m_lockedState ) return;
m_enabledState = false;
}
| C++ |
#include "timer.h"
CTimer g_timer;
CTimer::CTimer()
{
m_stopped = true;
m_inited = false;
m_usingQPF = false;
m_lastElapsedTime = 0.0;
m_baseTime = 0.0;
m_stopTime = 0.0;
m_currSysTime = 0.0;
m_currElapsedTime = 0.0;
m_baseMilliTime = 0.0;
m_currSysMilliTime = 0.0;
m_currElapsedMilliTime = 0.0;
m_QPFTicksPerSec = 0;
m_QPFStopTime = 0;
m_QPFLastElapsedTime = 0;
m_QPFBaseTime = 0;
}
CTimer::~CTimer()
{
Stop();
}
void CTimer::Start()
{
if( !m_inited )
{
LARGE_INTEGER qwTicksPerSec;
m_usingQPF = QueryPerformanceFrequency( &qwTicksPerSec );
if( m_usingQPF )
m_QPFTicksPerSec = qwTicksPerSec.QuadPart;
if( m_usingQPF )
{
QueryPerformanceCounter( &m_QPFTime );
m_QPFBaseTime = m_QPFTime.QuadPart;
m_currSysTime = m_QPFBaseTime / (double) m_QPFTicksPerSec;
m_baseTime = m_currSysTime;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_baseMilliTime = m_baseTime * 1000.0;
}
else
{
m_currSysTime = timeGetTime() * 0.001;
m_baseTime = m_currSysTime;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_baseMilliTime = m_baseTime * 1000.0;
}
m_inited = true;
}
if( m_usingQPF )
{
QueryPerformanceCounter( &m_QPFTime );
m_currSysTime = m_QPFTime.QuadPart / (double) m_QPFTicksPerSec;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_QPFStopTime = 0;
m_QPFLastElapsedTime = m_QPFTime.QuadPart;
}
else
{
m_currSysTime = timeGetTime() * 0.001;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_stopTime = 0.0f;
m_lastElapsedTime = m_currSysTime;
}
m_stopped = false;
}
void CTimer::Stop()
{
if( m_stopped ) return;
if( m_usingQPF )
{
QueryPerformanceCounter( &m_QPFTime );
m_currSysTime = m_QPFTime.QuadPart / (double) m_QPFTicksPerSec;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_QPFStopTime = m_QPFTime.QuadPart;
m_QPFLastElapsedTime = m_QPFTime.QuadPart;
}
else
{
m_currSysTime = timeGetTime() * 0.001;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_stopTime = m_currSysTime;
m_lastElapsedTime = m_currSysTime;
}
m_stopped = true;
}
void CTimer::Advance()
{
if( m_usingQPF )
m_QPFStopTime += m_QPFTicksPerSec / 10;
else
m_stopTime += 0.1f;
}
void CTimer::Reset()
{
if( m_usingQPF )
{
QueryPerformanceCounter( &m_QPFTime );
m_currSysTime = m_QPFTime.QuadPart / (double) m_QPFTicksPerSec;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_QPFBaseTime = m_QPFTime.QuadPart;
m_QPFLastElapsedTime = m_QPFTime.QuadPart;
m_QPFStopTime = 0;
m_baseTime = m_QPFBaseTime / (double) m_QPFTicksPerSec;
}
else
{
m_currSysTime = timeGetTime() * 0.001;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_baseTime = m_currSysTime;
m_lastElapsedTime = m_currSysTime;
m_stopTime = 0.0;
}
m_stopped = false;
}
float CTimer::Tick()
{
if( m_stopped )
{
if( m_usingQPF )
{
m_currSysTime = m_QPFStopTime / (double) m_QPFTicksPerSec;
m_currSysMilliTime = m_currSysTime * 1000.0;
}
else
{
m_currSysTime = m_stopTime;
m_currSysMilliTime = m_currSysTime * 1000.0;
}
}
else
{
if( m_usingQPF )
{
QueryPerformanceCounter( &m_QPFTime );
m_currSysTime = m_QPFTime.QuadPart / (double) m_QPFTicksPerSec;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_currElapsedTime = (double) ( m_QPFTime.QuadPart - m_QPFLastElapsedTime ) / (double) m_QPFTicksPerSec;
m_QPFLastElapsedTime = m_QPFTime.QuadPart;
m_currElapsedMilliTime = m_currElapsedTime * 1000.0;
}
else
{
m_currSysTime = timeGetTime() * 0.001;
m_currSysMilliTime = m_currSysTime * 1000.0;
m_currElapsedTime = (double) ( m_currSysTime - m_lastElapsedTime );
m_lastElapsedTime = m_currSysTime;
m_currElapsedMilliTime = m_currElapsedTime * 1000.0;
}
}
return (float) m_currElapsedTime;
}
float CTimer::GetAbsoluteTime()
{
if( m_stopped )
{
if( m_usingQPF )
{
return (float) ( m_QPFStopTime / (double) m_QPFTicksPerSec );
}
else
{
return (float) ( m_stopTime );
}
}
else
{
if( m_usingQPF )
{
QueryPerformanceCounter( &m_QPFTime );
return (float) ( m_QPFTime.QuadPart / (double) m_QPFTicksPerSec );
}
else
{
return (float) ( timeGetTime() * 0.001 );
}
}
} | C++ |
#include "bsp.h"
#include "camera.h"
#include "d3drender.h"
#define GTH_BSP_MAIN_MODEL 0
void CBSP::PrepareScene( vec3_t pos , DWORD frameFlag )
{
m_frameFlag = frameFlag + 1;
if(g_d3dRender.m_bFog)
{
if( m_visibleQuality == GTH_WORLD_VISIBLE_QUALITY_HIGH )
{
m_removeDist = m_visibleDist;
m_skyHeight = m_visibleDist * 0.4f;
}
else
{
m_removeDist = m_visibleDist * 0.5f;
m_skyHeight = m_visibleDist * 0.6f;
}
}
else
{
if( m_visibleQuality == GTH_WORLD_VISIBLE_QUALITY_HIGH )
{
m_removeDist = m_visibleDist;
m_skyHeight = m_visibleDist * 0.7f;
}
else
{
m_removeDist = m_visibleDist * 0.5f;
m_skyHeight = m_removeDist * 0.7f;
}
}
VectorCopy( m_camPos , pos );
MakeVis();
TravelModel( GTH_BSP_MAIN_MODEL );
}
void CBSP::MakeVis()
{
int cluster;
int currLeaf;
currLeaf = FindLeaf( m_camPos );
cluster = m_leaves[ currLeaf ].cluster;
if( cluster >= 0 )
m_visData = (BYTE *) &m_vis->data[ cluster * m_vis->rowSize ];
else
m_visData = (BYTE *) &m_vis->data[ m_vis->numClusters * m_vis->rowSize ];
}
int CBSP::FindCluster( vec3_t pos )
{
int currLeaf;
currLeaf = FindLeaf( pos );
return m_leaves[ currLeaf ].cluster;
}
int CBSP::FindLeaf( vec3_t pos )
{
float d;
node_t *node;
plane_t *plane;
int num = 0;
while( num >= 0 )
{
node = m_nodes + num;
plane = &m_planes[ node->plane ];
if( plane->type < 3 )
d = pos[plane->type] - plane->dist;
else
d = VectorDotProduct( plane->normal , pos ) - plane->dist;
if( d < 0 )
num = node->child[1];
else
num = node->child[0];
}
return -1 - num;
}
void CBSP::TravelModel( int modelIdx )
{
int i, j, cluster;
leafbaseface_t *face;
leaf_t *leaf;
int numFaces;
int *list;
if( modelIdx != GTH_BSP_MAIN_MODEL )
return;
for( i = 0 ; i < m_numLeaves ; i++ )
{
cluster = m_leaves[i].cluster;
if( cluster < 0 ) continue;
if( !( m_visData[cluster >> 3] & ( 1 << (cluster & 7) ) ) )
continue;
leaf = &m_leaves[i];
if( g_camera.m_frustum.Cull_Exact( leaf->mins , leaf->maxs ) )
continue;
if( !ChechVisibleDistance( leaf->mins , leaf->maxs ) )
continue;
list = &m_faceLists[ leaf->firstFace ];
numFaces = leaf->numFaces;
for ( j = 0 ; j < numFaces ; j++ , list++ )
{
face = &m_leafBaseFaces[ *list ];
if( face->frameFlag == m_frameFlag ) continue;
face->frameFlag = m_frameFlag;
TravelFace( face );
}
}
}
inline int CBSP::ChechVisibleDistance( const vec3_t mins , const vec3_t maxs )
{
vec3_t subMins, subMaxs;
VectorSubtract( subMins , mins , m_camPos );
VectorSubtract( subMaxs , maxs , m_camPos );
VectorAverage( subMins , subMins , subMaxs );
if( VectorDotProduct( subMins , subMins ) > m_removeDist * m_removeDist )
return false;
return true;
}
#define NEG_DIST_EPSILON -100.000f
inline void CBSP::TravelFace( leafbaseface_t *face )
{
shadermap_t *shaderMap;
float dist;
if( face->type == FACETYPE_NORMAL )
{
if( !( m_shaderMaps[ face->shader ].flags & SHADER_CULL_NONE ) )
{
dist = VectorDotProduct( face->normal , m_camPos ) - face->texDist;
if( ( m_shaderMaps[ face->shader ].flags & SHADER_CULL_FRONT ) && ( dist > 0 ) )
return;
else if( dist < NEG_DIST_EPSILON )
return;
}
}
else if( face->type == FACETYPE_PATCH )
{
if( g_camera.m_frustum.Cull_Exact( face->mins , face->maxs ) )
return;
}
shaderMap = &m_shaderMaps[ face->shader ];
if( shaderMap->LMFrameFlags[ face->lmap ] != m_frameFlag )
{
shaderMap->LMFrameFlags[ face->lmap ] = m_frameFlag;
shaderMap->frameFlag = m_frameFlag;
face->next = NULL;
shaderMap->LMMaps[ face->lmap ].linked = face;
}
else
{
face->next = shaderMap->LMMaps[ face->lmap ].linked;
shaderMap->LMMaps[ face->lmap ].linked = face;
}
} | C++ |
#ifndef _D3DDEVICE_H
#define _D3DDEVICE_H
#include <d3dx8.h>
#define GTH_NULL_FOG_TYPE 0
#define GTH_VERTEX_FOG_TYPE 1
#define GTH_PIXEL_FOG_TYPE 2
class CD3DDevice
{
public:
enum { VS_FFP = 0,
VS_1_1,
VS_2_0,
VS_3_0 };
CD3DDevice();
LPDIRECT3DDEVICE8 GetD3DDevice() const { return m_pd3dDevice; }
bool IsDevice() const { return m_pd3dDevice != NULL; }
void SetD3DDevice(LPDIRECT3DDEVICE8 pd3dDevice);
void ReleaseDevice();
void ActivateDevice();
void PassivateDevice();
const D3DCAPS8& GetCaps() const { return m_d3dCaps; }
int GetVShaderVersion() const { return m_VShaderVersion; }
int GetFogType() const { return m_FogType; }
int GetScreenWidth() const { return m_ScreenWidth; }
int GetScreenHeight() const { return m_ScreenHeight; }
D3DFORMAT GetScreenFormat() const { return m_ScreenFormat; }
float GetScreenAspect() const { return m_ScreenAspect; }
LPDIRECT3DSURFACE8 GetBackBuffer() const { return m_pBackBuffer; }
LPDIRECT3DSURFACE8 GetMainZStencilSurface() const { return m_pMainZStencilSurface; }
void SetScreen(int width, int height, D3DFORMAT format)
{
m_ScreenWidth = width;
m_ScreenHeight = height;
m_ScreenFormat = format;
m_ScreenAspect = (float)width / (float)height;
}
private:
int m_VShaderVersion;
int m_ScreenWidth;
int m_ScreenHeight;
D3DFORMAT m_ScreenFormat;
float m_ScreenAspect;
D3DCAPS8 m_d3dCaps;
LPDIRECT3DDEVICE8 m_pd3dDevice;
LPDIRECT3DSURFACE8 m_pBackBuffer;
LPDIRECT3DSURFACE8 m_pMainZStencilSurface;
DWORD m_dwCreateFlags;
int m_FogType;
};
extern CD3DDevice g_d3dDevice;
#endif
| C++ |
#ifndef _FX_RESOURCE_COUNTER_H_EWEHQW9E23GAVXVAPQPQPFK23T0UDFKLGJLKJQEDQ
#define _FX_RESOURCE_COUNTER_H_EWEHQW9E23GAVXVAPQPQPFK23T0UDFKLGJLKJQEDQ
enum
{
RESCOUNTER_TEXTURE_MODEL_MAP = 0,
RESCOUNTER_TEXTURE_MODEL_LIGHTMAP,
RESCOUNTER_TEXTURE_MODEL_OTHERS,
RESCOUNTER_TEXTURE_CHAR_PC,
RESCOUNTER_TEXTURE_CHAR_NPC,
RESCOUNTER_TEXTURE_CHAR_MONSTER,
RESCOUNTER_TEXTURE_INTERFACE,
RESCOUNTER_MESH_MODEL_MAP,
RESCOUNTER_MESH_MODEL_ITEM,
RESCOUNTER_MESH_MODEL_EFFECT,
RESCOUNTER_MESH_CHAR_PC,
RESCOUNTER_MESH_CHAR_NPC,
RESCOUNTER_MESH_CHAR_MONSTER,
RESCOUNTER_ANIM_CHAR_PC,
RESCOUNTER_ANIM_CHAR_NPC,
RESCOUNTER_ANIM_CHAR_MONSTER,
RESCOUNTER_CHAR_CHARACTERMANAGER,
RESCOUNTER_CHAR_ANIMATIONMANAGER,
RESCOUNTER_CHAR_ITEMMANAGER,
RESCOUNTER_CHAR_SKINMANAGER,
RESCOUNTER_CHAR_AURARENDERER,
RESCOUNTER_CHAR_ITEMRENDERER,
RESCOUNTER_CHAR_SKINRENDERER,
RESCOUNTER_SKEL,
RESCOUNTER_ETC,
RES_DATATYPE_NUM,
};
enum
{
RESCOUNTER_VB_DEFAULT = 0,
RESCOUNTER_VB_MANAGED,
RESCOUNTER_IB_DEFAULT,
RESCOUNTER_IB_MANAGED,
RESCOUNTER_TEXTURE_DEFAULT,
RESCOUNTER_TEXTURE_MANAGED,
RES_MEMTYPE_NUM,
};
extern char *RES_DATATYPE_TEXT[];
extern char *RES_MEMTYPE_TEXT[];
class CResCounter
{
public:
CResCounter();
~CResCounter();
void Clear ();
void EnableResCounter ();
void DisableResCounter ();
void LockResCounter ();
bool Enabled () { return m_enabledState; }
void Reset_DataType ( int in_dataType );
void Reset_MemoryType ( int in_memType );
int Add_DataType ( int in_dataType, int in_size );
int Add_MemoryType ( int in_memType, int in_size );
int PrintOut ();
protected:
bool m_enabledState;
bool m_lockedState;
int m_sizeDataType[ RES_DATATYPE_NUM ];
int m_dataCount;
int m_sizeMemType[ RES_MEMTYPE_NUM ];
int m_memCount;
};
extern CResCounter *g_resCounter;
#endif | C++ |
#if !defined(AFX_SHADERMNG_H__695B05D6_23DD_4B58_9867_AA85C5B19C62__INCLUDED_)
#define AFX_SHADERMNG_H__695B05D6_23DD_4B58_9867_AA85C5B19C62__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "shader.h"
#define MAX_SIZE_SHADERS 4096
#define MAX_SIZE_ANIMS 128
#define MAX_SIZE_ENV_SKYS 64
class CShaderMng
{
public:
CShaderMng();
CShaderMng( int owner );
virtual ~CShaderMng();
int m_owner;
shader_t *m_shaders;
int m_numShaders;
int m_maxSizeShader;
anim_t m_animMaps[ MAX_SIZE_ANIMS ];
envsky_t m_envSkys[ MAX_SIZE_ENV_SKYS ];
int m_numAnimMaps;
int m_numEnvSkys;
void SetOwner ( int owner ) { m_owner = owner; }
int Init( int sizeShader );
int GetShaderCount( char *fName , DWORD size = 0 , BYTE *data = NULL );
int ReadShaderScript( char *fName , DWORD size = 0 , BYTE *data = NULL );
int SearchShader( char *name );
shader_t *GetShader( int idx );
shader_t *GetShader( char *name );
int MakeDefaultShader( char *name );
void InitShader( int idxShader );
void Release();
void Release( int idxShader );
void EvaluateTcMod( shaderpass_t *pass , float time );
void EvaluateTcModFunc( tcmodfunc_t *tcmodFunc, float asyncTime );
float EvaluateFunc( wavefunc_t *func, float asyncTime );
float EvaluateFunc( wavefunc_t *func , float offset , float asyncTime );
void PrepareShader( int idxShader , DWORD frameFlag );
void PrepareShader( int idxShader , float time );
void PrepareTCGen( shader_t *shader , vec3_t pos );
private:
int GetShaderTexRef( char *textureName );
void ParseShaderPass( shader_t *shader );
void ParseShaderToken( shader_t *shader , char *token );
void ParseShaderPassToken( shader_t *shader , shaderpass_t *pass , char *token );
shader_t *GetNewShader( char *name );
wavetype_t ParseWaveFunc( char *param );
void ShaderKeyFunc_skyparms( shader_t *shader );
void ShaderKeyFunc_cull( shader_t *shader );
void ShaderKeyFunc_deformvertexes( shader_t *shader );
void ShaderKeyFunc_sort( shader_t *shader );
void ShaderKeyFunc_surfaceparm( shader_t *shader );
void ShaderPassKeyFunc_map( shader_t *shader , shaderpass_t *pass );
void ShaderPassKeyFunc_clampmap( shader_t *shader , shaderpass_t *pass );
void ShaderPassKeyFunc_animmap( shader_t *shader , shaderpass_t *pass );
void ShaderPassKeyFunc_blendfunc( shader_t *shader , shaderpass_t *pass );
void ShaderPassKeyFunc_rgbgen( shader_t *shader , shaderpass_t *pass );
void ShaderPassKeyFunc_alphagen( shader_t *shader , shaderpass_t *pass );
void ShaderPassKeyFunc_tcgen( shader_t *shader , shaderpass_t *pass );
void ShaderPassKeyFunc_depthfunc( shader_t *shader , shaderpass_t *pass );
void ShaderPassKeyFunc_alphafunc( shader_t *shader , shaderpass_t *pass );
void ShaderPassKeyFunc_tcmod( shader_t *shader , shaderpass_t *pass );
};
extern CShaderMng g_shaderMng;
#endif
| C++ |
#if !defined(AFX_BSP_H__12B14CD1_433E_4248_A0AE_84CB4822E7A5__INCLUDED_)
#define AFX_BSP_H__12B14CD1_433E_4248_A0AE_84CB4822E7A5__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "gth_bsp.h"
#include "frustum.h"
#include "shadermng.h"
#include "d3dbuffer.h"
#include "collide.h"
#include "decal.h"
enum
{
SKYBOX_TOP = 0,
SKYBOX_FRONT,
SKYBOX_RIGHT,
SKYBOX_BACK,
SKYBOX_LEFT,
SKYBOX_DOWN
};
typedef struct
{
int bank;
int baseVB;
int sizeVB;
leafbaseface_t *linked;
} shaderLMmap_t;
#define MAX_SHADERMAP_LM 256
typedef struct
{
DWORD flags;
int shader;
DWORD frameFlag;
DWORD LMFrameFlags[ MAX_SHADERMAP_LM ];
shaderLMmap_t LMMaps[ MAX_SHADERMAP_LM ];
} shadermap_t;
typedef struct
{
vec3_t point;
vec3_t normal;
vec2_t texUV;
} shadowvertex_t;
#define GTH_BSP_FORMAT ( GTH_FORMAT_XYZ | GTH_FORMAT_NORMAL | GTH_FORMAT_DIFFUSE | GTH_FORMAT_TEXVERTEX( 2 ) )
#define GTH_SHADOW_FORMAT ( GTH_FORMAT_XYZ | GTH_FORMAT_NORMAL | GTH_FORMAT_TEXVERTEX( 1 ) )
#define GTH_SHADOW_FORMAT_NEO ( GTH_FORMAT_XYZ | GTH_FORMAT_TEXVERTEX( 1 ) )
#define MAX_SIZE_LIGHTMAP_TEXTURE_REFERENCE 256
#define MAX_SIZE_STATIC_VERTEX_BUFFER_BANK 16
#define MAX_SIZE_DYNAMIC_VERTEX_BUFFER 1024 * 10
#define MAX_SIZE_DYNAMIC_INDEX_BUFFER 1024 * 64
#define MAX_SIZE_TEMP_VERTEX_BUFFER 1024 * 10
#define MAX_SIZE_DYNAMIC_SHADOW_VERTEX_BUFFER 1024 * 4
#define MAX_BANKSIZE_VERTEXBUFFER 1024 * 64
#define GTH_WORLD_VISIBLE_QUALITY_LOW 1
#define GTH_WORLD_VISIBLE_QUALITY_HIGH 0
#define MAX_SIZE_FILENAME 128
class CBSP
{
public:
int m_id;
char m_name[GTH_MAX_SIZE_FILENAME];
vec3_t m_camPos;
vec3_t m_camDir;
float m_skyHeight;
int m_totalRenderPolygon;
shadermap_t *m_shaderMaps;
int m_lmapTexRefs[ MAX_SIZE_LIGHTMAP_TEXTURE_REFERENCE ];
CFXDecal m_decal;
int m_numBank;
int m_numDeformVerts;
int m_numStaticElems;
int m_bankSize[ MAX_SIZE_STATIC_VERTEX_BUFFER_BANK ];
CD3DBuffer *m_staticVB[ MAX_SIZE_STATIC_VERTEX_BUFFER_BANK ];
CD3DBuffer *m_dynamicVB;
CD3DBuffer *m_dynamicIB;
CD3DBuffer *m_shadowVB;
WORD *m_staticEB;
vertex_t *m_deformVB;
vertex_t *m_tempVB;
DWORD m_frameFlag;
float m_visibleDist;
float m_removeDist;
int m_visibleQuality;
BYTE *m_visData;
int m_maxPatchLevel;
int m_subDivTolerance;
DWORD m_format;
DWORD m_shadowFormat;
int m_currBank;
BYTE *m_buffer;
shadertypehead_t *m_shaderType;
shaderref_t *m_shaderRefs;
int m_numShaderRefs;
plane_t *m_planes;
int m_numPlanes;
node_t *m_nodes;
int m_numNodes;
leaf_t *m_leaves;
int m_numLeaves;
facelist_t *m_faceLists;
int m_numFaceLists;
brushlist_t *m_brushLists;
int m_numBrushLists;
model_t *m_models;
int m_numModels;
brush_t *m_brushes;
int m_numBrushes;
brushside_t *m_brushSides;
int m_numBrushSides;
vertex_t *m_vertices;
int m_numVertices;
element_t *m_elems;
int m_numElems;
face_t *m_faces;
int m_numFaces;
lightmap_t *m_lightmaps;
int m_numLightmaps;
gridlight_t *m_gridLights;
int m_numGridLights;
visibility_t *m_vis;
leafbaseface_t *m_leafBaseFaces;
gridfacelumphead_t *m_gridFaceLumpHead;
gridfacelump_t *m_gridFaceLumps;
int m_numGridFaceLumps;
gridfacelist_t *m_gridFaceLists;
int m_numGridFaceLists;
DWORD m_shadowFrameFlag;
CBSP();
~CBSP();
void Release();
int Load( char *mapName );
int GenDynamicMem();
void SetID( int id ) { m_id = id; }
void SetFrameFlag( DWORD frameFlag ) { m_frameFlag = frameFlag; }
void SetvisibleQuality( int quality ) { m_visibleQuality = quality; }
BYTE *GetVisData() { return m_visData; }
int PrepareShaderMap();
int Initialize( float visibleDist );
int Restore();
void PrepareVertexBuffer();
int UploadVertexBuffer();
void PrepareScene( vec3_t pos , DWORD frameFlag );
void MakeVis();
int FindCluster( vec3_t pos );
int FindLeaf( vec3_t pos );
void TravelModel( int modelIdx );
inline int ChechVisibleDistance( const vec3_t mins , const vec3_t maxs );
inline void TravelFace( leafbaseface_t *face );
void RenderBefore();
void RenderAfter();
inline void RenderDefault( const shaderLMmap_t *LMMap );
inline void RenderCustom( shader_t *shader , const shaderLMmap_t *LMMap , const int idxLM );
inline void RenderDeform( shader_t *shader , const shaderLMmap_t *LMMap , const int idxLM );
inline void RenderSky( shader_t *shader , const shaderLMmap_t *LMMap , const int idxLM );
trace_t Trace( vec3_t start , vec3_t mins , vec3_t maxs , vec3_t end , int brushmask );
void RecursiveHullCheck( int num , float p1f , float p2f , vec3_t p1 , vec3_t p2 );
void TraceToLeaf( int leafnum );
void ClipBoxToBrush( vec3_t mins , vec3_t maxs , vec3_t p1 , vec3_t p2
, trace_t *trace , brush_t *brush );
int PointContents( vec3_t pos );
void SetShadowRenderState();
void RenderProjectiveShadow( vec3_t p1 , vec3_t p2 , vec3_t p3 , vec3_t p4 , LPDIRECT3DTEXTURE8 d3dTex );
bool RenderProjectiveShadowNeo( float in_size, vec3_t p1, CD3DBuffer* pBuffer, int& vertexSize);
void SetDecalBuffer();
void SetDecalInit(matrix4x4_t* matShadow, vec3_t& vLight, vec3_t& sunAngle, float dispPS, float min, float max);
private:
int CalcPatchSize( face_t *face , int *numVerts , int *numElems );
void GenPatch( face_t *face , int baseVB , vertex_t *ptrStaticVB , WORD *ptrStaticEB );
void FillBezierCurve( int , unsigned int , unsigned int , unsigned int , vertex_t* );
int FindPatchLevel( vec3_t *v );
int FindPatchSize( int *patchSize, vertex_t *cp, int *size );
void CalcSkySize( int shaderFlag , int *numVerts , int *numElems );
void GenSky( face_t *face , int baseVB , int shaderFlag , vertex_t *ptrStaticVB , WORD *ptrStaticEB );
void GenEnvSkyBox( vertex_t *ptrVB , WORD *ptrEB , int baseVB );
void GenSkyBox( vertex_t *ptrVB );
void GenSkyBoxSide( int side, vec3_t orig, vec3_t drow, vec3_t dcol, vertex_t * ptrVB );
void GenSkyBox_Neo ( vertex_t *in_vb );
void GenSkyVertices ( vec3_t in_forward, vec3_t in_up, vec3_t in_right, int in_numTess, float in_skySize, vertex_t *in_vb );
void GenSkyTexCoords ( float in_skyHeight, int in_numVtx, vertex_t *in_vb );
void GenSkyBox_Lee ( vertex_t *in_vb );
};
#endif
| C++ |
#include "bsp.h"
#define LEVEL_WIDTH(lvl) ((1 << (lvl+1)) + 1)
int CBSP::CalcPatchSize( face_t *face , int *numVerts , int *numElems )
{
int size[2];
vertex_t *vert = &m_vertices[ face->vertexOffset ];
if( !FindPatchSize( face->patchSize , vert , size ) )
return false;
*numVerts = size[0] * size[1];
*numElems = ( size[0] - 1 ) * ( size[1] - 1 ) * 6;
return true;
}
void CBSP::GenPatch( face_t *face , int baseVB , vertex_t *ptrStaticVB , WORD *ptrStaticEB )
{
int step[2], size[2], len, u, v, p;
vertex_t *vert;
vertex_t *ptrVB = m_tempVB;
WORD *ptrEB = ptrStaticEB;
vert = &m_vertices[ face->vertexOffset ];
if( !FindPatchSize( face->patchSize , vert , size ) )
{
face->sizeVB = 0;
face->sizeEB = 0;
return;
}
len = size[0] * size[1];
step[0] = (size[0]-1) / (face->patchSize[0]-1);
step[1] = (size[1]-1) / (face->patchSize[1]-1);
for( v = 0 ; v < size[1] ; v += step[1] )
{
for( u = 0 ; u < size[0] ; u += step[0] , vert++ )
{
p = v * size[0] + u;
memcpy( ptrVB + p , vert , sizeof( vertex_t ) );
}
}
for( u = 0; u < size[0] ; u += step[0] )
{
FillBezierCurve( face->patchSize[1] , size[1] , size[0] , u , ptrVB );
}
for( v = 0; v < size[1]; v++ )
{
FillBezierCurve( face->patchSize[0] , size[0] , 1 , v * size[0] , ptrVB );
}
memcpy( ptrStaticVB , ptrVB , sizeof( vertex_t ) * len );
for (v = 0; v < size[1]-1; ++v)
{
for (u = 0; u < size[0]-1; ++u)
{
*ptrEB++ = (WORD) ( baseVB + v * size[0] + u );
*ptrEB++ = (WORD) ( baseVB + (v+1) * size[0] + u );
*ptrEB++ = (WORD) ( baseVB + v * size[0] + u + 1 );
*ptrEB++ = (WORD) ( baseVB + v * size[0] + u + 1 );
*ptrEB++ = (WORD) ( baseVB + (v+1) * size[0] + u );
*ptrEB++ = (WORD) ( baseVB + (v+1) * size[0] + u + 1 );
}
}
face->sizeVB = len;
face->sizeEB = ( size[0] - 1 ) * ( size[1] - 1 ) * 6;
}
void CBSP::FillBezierCurve( int patchSize, unsigned int size, unsigned int stride,
unsigned int pos, vertex_t *patchVertex )
{
vertex_t *vertex;
unsigned int step, halfstep, i, mid, p0, p1, dounlestep ;
unsigned int half0, half1;
vec3_t positionA , positionB;
vec3_t normalA , normalB;
vec2_t texCoordA , texCoordB;
vec2_t LMCoordA , LMCoordB;
color_t colorA , colorB;
step = ( size - 1 ) / ( patchSize - 1 );
vertex = &patchVertex[pos];
while( step > 0 )
{
halfstep = step >> 1 ;
dounlestep = step << 1;
for( i = 0; i < size - 1 ; i += dounlestep )
{
p0 = ( i + step*0 ) * stride;
mid = ( i + step*1 ) * stride;
p1 = ( i + step*2 ) * stride;
VectorAverage( positionA , vertex[p0].point , vertex[mid].point );
VectorAverage( positionB , vertex[mid].point , vertex[p1].point );
VectorAverage( vertex[mid].point , positionA , positionB );
VectorAverage( normalA , vertex[p0].normal , vertex[mid].normal );
VectorAverage( normalB , vertex[mid].normal , vertex[p1].normal );
VectorAverage( vertex[mid].normal , normalA , normalB );
Vector2Average( texCoordA , vertex[p0].texUV , vertex[mid].texUV );
Vector2Average( texCoordB , vertex[mid].texUV , vertex[p1].texUV );
Vector2Average( vertex[mid].texUV , texCoordA , texCoordB );
Vector2Average( LMCoordA , vertex[p0].lmapUV , vertex[mid].lmapUV );
Vector2Average( LMCoordB , vertex[mid].lmapUV , vertex[p1].lmapUV );
Vector2Average( vertex[mid].lmapUV , LMCoordA , LMCoordB );
ColorAverage( colorA , vertex[p0].diffuse , vertex[mid].diffuse );
ColorAverage( colorB , vertex[mid].diffuse , vertex[p1].diffuse );
ColorAverage( vertex[mid].diffuse , colorA , colorB );
if ( halfstep > 0 )
{
half0 = ( i + halfstep*1 ) * stride;
half1 = ( i + halfstep*3 ) * stride;
VectorCopy( vertex[half0].point , positionA );
VectorCopy( vertex[half1].point , positionB );
VectorCopy( vertex[half0].normal , normalA );
VectorCopy( vertex[half1].normal , normalB );
Vector2Copy( vertex[half0].texUV , texCoordA );
Vector2Copy( vertex[half1].texUV , texCoordB );
Vector2Copy( vertex[half0].lmapUV , LMCoordA );
Vector2Copy( vertex[half1].lmapUV , LMCoordB );
ColorCopy( vertex[half0].diffuse , colorA );
ColorCopy( vertex[half1].diffuse , colorB );
}
}
step = halfstep;
}
}
int CBSP::FindPatchLevel( vec3_t *v )
{
int level;
vec3_t a, b, dist;
for( level=0; level < m_maxPatchLevel - 1; level++ ) {
VectorAverage( a , v[0], v[1] );
VectorAverage( b , v[1], v[2] );
VectorAverage( v[2] , a, b );
VectorSubtract( dist , v[2], v[1] );
if( VectorDotProduct( dist, dist ) < m_subDivTolerance * m_subDivTolerance )
break;
VectorCopy( v[1] , a );
}
return( level );
}
int CBSP::FindPatchSize( int *patchSize, vertex_t *cp, int *size )
{
int u, v, found, level;
vec3_t a, b;
vec3_t test[3];
found = 0;
for (v=0; v < patchSize[1]; v++)
{
for (u=0; u < patchSize[0]-1; u += 2)
{
VectorCopy( a , cp[v * patchSize[0] + u].point );
VectorCopy( b , cp[v * patchSize[0] + u + 2].point );
if (!VectorCompare(a,b))
{
found = 1;
break;
}
}
if (found) break;
}
if (!found) {
GTH_ERROR( GTH_ERROR_PRINT , "Bad Patch control points" );
return false;
}
VectorCopy( test[0] , a );
VectorCopy( test[1] , (a+3) );
VectorCopy( test[2] , b );
level = FindPatchLevel(test);
size[0] = 2 * ( patchSize[0] - 1 ) + 1;
found = 0;
for (u=0; u < patchSize[0]; u++)
{
for (v=0; v < patchSize[1]-1; v += 2)
{
VectorCopy( a , cp[v * patchSize[0] + u].point );
VectorCopy( b , cp[(v + 2) * patchSize[0] + u].point );
if (!VectorCompare(a,b))
{
found = 1;
break;
}
}
if (found)
break;
}
if (!found) {
GTH_ERROR( GTH_ERROR_PRINT , "Bad Patch control points" );
return false;
}
VectorCopy( test[0] , a );
VectorCopy( test[1] , (a+patchSize[0]*3) );
VectorCopy( test[2] , b );
level = FindPatchLevel(test);
size[1] = 2 * ( patchSize[1] - 1 ) + 1;
return true;
} | C++ |
#include "bsp.h"
#include "collide.h"
#define DIST_EPSILON (0.03125f)
vec3_t trace_start , trace_end;
vec3_t trace_mins , trace_maxs;
vec3_t trace_extents;
trace_t trace_trace;
int trace_contents;
int trace_ispoint;
int checkCount = 0;
trace_t CBSP::Trace( vec3_t start , vec3_t mins , vec3_t maxs , vec3_t end , int brushmask )
{
int i;
int headnode = 0;
checkCount++;
memset (&trace_trace, 0, sizeof(trace_trace));
trace_trace.fraction = 1.0f;
trace_trace.surfaceFlags = 0;
trace_contents = brushmask;
VectorCopy( trace_start , start );
VectorCopy( trace_end , end );
VectorCopy( trace_mins , mins );
VectorCopy( trace_maxs , maxs );
if( VectorCompare( start , end ) )
{
VectorCopy( trace_trace.endpos , start );
return trace_trace;
}
if( mins[0] == 0 && mins[1] == 0 && mins[2] == 0
&& maxs[0] == 0 && maxs[1] == 0 && maxs[2] == 0 )
{
trace_ispoint = true;
VectorClear( trace_extents );
}
else
{
trace_ispoint = false;
trace_extents[0] = -mins[0] > maxs[0] ? -mins[0] : maxs[0];
trace_extents[1] = -mins[1] > maxs[1] ? -mins[1] : maxs[1];
trace_extents[2] = -mins[2] > maxs[2] ? -mins[2] : maxs[2];
}
RecursiveHullCheck( headnode , 0 , 1 , start , end );
if( trace_trace.fraction == 1.0f )
{
VectorCopy( trace_trace.endpos , end );
}
else
{
for( i = 0 ; i < 3 ; i++ )
trace_trace.endpos[i] = start[i] + trace_trace.fraction * ( end[i] - start[i] );
}
return trace_trace;
}
void CBSP::RecursiveHullCheck( int num , float p1f , float p2f , vec3_t p1 , vec3_t p2 )
{
node_t *node;
plane_t *plane;
float t1, t2, offset;
float frac, frac2;
float idist;
int i;
vec3_t mid;
int side;
float midf;
if( trace_trace.fraction <= p1f )
return;
if( num < 0 )
{
TraceToLeaf( -1-num );
return;
}
node = m_nodes + num;
plane = &m_planes[ node->plane ];
if( plane->type < 3 )
{
t1 = p1[plane->type] - plane->dist;
t2 = p2[plane->type] - plane->dist;
offset = trace_extents[plane->type];
}
else
{
t1 = VectorDotProduct( plane->normal , p1 ) - plane->dist;
t2 = VectorDotProduct( plane->normal , p2 ) - plane->dist;
if( trace_ispoint )
offset = 0;
else
offset = fabs(trace_extents[0]*plane->normal[0])
+ fabs(trace_extents[1]*plane->normal[1])
+ fabs(trace_extents[2]*plane->normal[2]);
}
if( t1 >= offset && t2 >= offset )
{
RecursiveHullCheck( node->child[0] , p1f , p2f , p1 , p2 );
return;
}
if( t1 < -offset && t2 < -offset )
{
RecursiveHullCheck( node->child[1] , p1f , p2f , p1 , p2 );
return;
}
if( t1 < t2 )
{
idist = 1.0f / ( t1 - t2 );
side = 1;
frac2 = ( t1 + offset + DIST_EPSILON ) * idist;
frac = ( t1 - offset + DIST_EPSILON ) * idist;
}
else if (t1 > t2)
{
idist = 1.0f / ( t1 - t2 );
side = 0;
frac2 = ( t1 - offset - DIST_EPSILON ) * idist;
frac = ( t1 + offset + DIST_EPSILON ) * idist;
}
else
{
side = 0;
frac = 1.0f;
frac2 = 0;
}
if( frac < 0.0f )
frac = 0.0f;
if( frac > 1.0f )
frac = 1.0f;
midf = p1f + ( p2f - p1f ) * frac;
for( i = 0 ; i < 3 ; i++ )
mid[i] = p1[i] + frac * ( p2[i] - p1[i] );
RecursiveHullCheck( node->child[ side ] , p1f , midf , p1 , mid );
if( frac2 < 0.0f )
frac2 = 0.0f;
if( frac2 > 1.0f )
frac2 = 1.0f;
midf = p1f + ( p2f - p1f ) * frac2;
for( i = 0 ; i < 3 ; i++ )
mid[i] = p1[i] + frac2 * ( p2[i] - p1[i] );
RecursiveHullCheck( node->child[ side^1 ] , midf , p2f , mid , p2 );
}
void CBSP::TraceToLeaf( int leafnum )
{
int k;
int brushnum;
leaf_t *leaf;
brush_t *b;
leaf = &m_leaves[ leafnum ];
for( k = 0 ; k < leaf->numBrushes ; k++ )
{
brushnum = m_brushLists[ leaf->firstBrush + k ];
b = &m_brushes[ brushnum ];
if( b->checkCount == checkCount )
continue;
b->checkCount = checkCount;
if( !( m_shaderRefs[ b->shaderInfo ].contents & trace_contents ) )
continue;
ClipBoxToBrush( trace_mins , trace_maxs , trace_start , trace_end , &trace_trace , b );
if( !trace_trace.fraction )
return;
}
}
void CBSP::ClipBoxToBrush( vec3_t mins , vec3_t maxs , vec3_t p1 , vec3_t p2
, trace_t *trace , brush_t *brush )
{
int i, j;
plane_t *plane, *clipplane;
float dist;
float enterfrac, leavefrac;
vec3_t ofs;
float d1, d2;
int getout, startout;
float f;
brushside_t *side, *leadside;
enterfrac = -1;
leavefrac = 1;
clipplane = NULL;
if( !brush->numSides )
return;
getout = false;
startout = false;
leadside = NULL;
for( i = 0 ; i < brush->numSides ; i++ )
{
side = &m_brushSides[ brush->firstSide + i ];
plane = &m_planes[ side->plane ];
if( !trace_ispoint )
{
for( j = 0 ; j < 3 ; j++ )
{
if( plane->normal[j] < 0 )
ofs[j] = maxs[j];
else
ofs[j] = mins[j];
}
dist = VectorDotProduct( ofs, plane->normal );
dist = plane->dist - dist;
}
else
{
dist = plane->dist;
}
d1 = VectorDotProduct( p1 , plane->normal ) - dist;
d2 = VectorDotProduct( p2 , plane->normal ) - dist;
if( d2 > 0 )
getout = true;
if( d1 > 0 )
startout = true;
if( d1 > 0 && d2 >= d1 )
return;
if( d1 <= 0 && d2 <= 0 )
continue;
if( d1 > d2 )
{
f = ( d1 - DIST_EPSILON ) / ( d1 - d2 );
if( f > enterfrac )
{
enterfrac = f;
clipplane = plane;
leadside = side;
}
}
else
{
f = ( d1 + DIST_EPSILON ) / ( d1 - d2 );
if( f < leavefrac )
leavefrac = f;
}
}
if( !startout )
{
trace->startsolid = true;
if( !getout )
trace->allsolid = true;
return;
}
if( enterfrac < leavefrac )
{
if( enterfrac > -1 && enterfrac < trace->fraction )
{
if( enterfrac < 0 )
enterfrac = 0;
trace->fraction = enterfrac;
trace->plane = clipplane;
trace->surfaceFlags = m_shaderRefs[ leadside->shaderInfo ].surfaceFlags;
trace->contents = m_shaderRefs[ leadside->shaderInfo ].contents;
}
}
}
int CBSP::PointContents( vec3_t pos )
{
int contents;
int leaf;
int *idxBrush;
plane_t *plane;
brush_t *brush;
brushside_t *side;
int numBrushes,numSides;
int i,j;
float dist;
contents = 0;
leaf = FindLeaf( pos );
if( leaf < 0 )
return contents;
numBrushes = m_leaves[ leaf ].numBrushes;
idxBrush = &m_brushLists[ m_leaves[ leaf ].firstBrush ];
for ( i = 0 ; i < numBrushes ; i++ , idxBrush++ )
{
brush = &m_brushes[ *idxBrush ];
side = &m_brushSides[ brush->firstSide ];
numSides = brush->numSides;
for( j = 0 ; j < numSides ; j++ , side++ )
{
plane = &m_planes[ side->plane ];
if( plane->type < 3 )
{
dist = pos[ plane->type ] - plane->dist;
}
else
{
dist = VectorDotProduct( plane->normal , pos ) - plane->dist;
}
if( dist >= 0 ) break;
}
if( j == numSides )
{
contents |= m_shaderRefs[ brush->shaderInfo ].contents;
return contents;
}
}
return contents;
}
| C++ |
#include "Decal.h"
CFXDecal::CFXDecal ()
{
m_maxNumVertices = 0;
}
CFXDecal::~CFXDecal ()
{
}
void CFXDecal::Setup ( matrix4x4_t *in_matrix,
vertex_t *in_vertices,
element_t *in_indices,
vec3_t &in_light,
float in_size )
{
SetInvTransformMatrix ( in_matrix );
SetVertices ( in_vertices );
SetIndices ( in_indices );
SetLight ( in_light );
SetSize ( in_size );
Initialize ();
}
bool CFXDecal::Process ( face_t &in_face )
{
if ( ! CheckFaceNormalAndLightDir ( in_face.planeNormal ) ) return false;
m_triangles = in_face.elemSize / 3;
vec3_t result [3];
int vtxIndex [3];
int index, subindex;
int counter = 0;
for ( index = 0; \
index < m_triangles; \
++index )
{
for ( subindex = 0; \
subindex < 3; \
++subindex, ++counter )
{
vtxIndex [subindex] = in_face.vertexOffset + m_indices [in_face.elemOffset + counter];
}
if ( ( m_vertices [vtxIndex [0]].point [2] > m_maxHeight ) &&
( m_vertices [vtxIndex [1]].point [2] > m_maxHeight ) &&
( m_vertices [vtxIndex [2]].point [2] > m_maxHeight ) )
continue;
if ( ( m_vertices [vtxIndex [0]].point [2] < m_minHeight ) &&
( m_vertices [vtxIndex [1]].point [2] < m_minHeight ) &&
( m_vertices [vtxIndex [2]].point [2] < m_minHeight ) )
continue;
for ( subindex = 0; \
subindex < 3; \
++subindex )
{
VectorCopy ( m_vtxBuffer [m_numVertices + subindex].pos, m_vertices [vtxIndex [subindex]].point );
m_invTransform.Transform ( m_tempBuffer [subindex], m_vertices [vtxIndex [subindex]].point );
CalculateCrossPoint ( m_tempBuffer [subindex], result [subindex] );
}
if ( ! CheckTriangleIsInsideDecal () )
{
continue;
}
CalculateNewTexCoords ( result, m_numVertices );
m_numVertices += 3;
#ifdef _DEBUG
if ( m_numVertices > m_maxNumVertices )
m_maxNumVertices = m_numVertices;
#endif
if ( m_numVertices > ( SHADOW_VERTEX_BUFFER_SIZE - 3 ) )
{
return false;
}
}
return true;
}
int CFXDecal::CheckTriangleIsInsideDecal ()
{
if ( ( m_tempBuffer [0][0] > m_halfLength ) &&
( m_tempBuffer [1][0] > m_halfLength ) &&
( m_tempBuffer [2][0] > m_halfLength ) )
return false;
if ( ( m_tempBuffer [0][0] < -m_halfLength ) &&
( m_tempBuffer [1][0] < -m_halfLength ) &&
( m_tempBuffer [2][0] < -m_halfLength ) )
return false;
if ( ( m_tempBuffer [0][1] > m_halfLength ) &&
( m_tempBuffer [1][1] > m_halfLength ) &&
( m_tempBuffer [2][1] > m_halfLength ) )
return false;
if ( ( m_tempBuffer [0][1] < -m_halfLength ) &&
( m_tempBuffer [1][1] < -m_halfLength ) &&
( m_tempBuffer [2][1] < -m_halfLength ) )
return false;
return true;
}
inline int CFXDecal::CheckFaceNormalAndLightDir ( vec3_t &in_normal )
{
if ( VectorDotProduct ( in_normal, m_normLight ) >= 0.0f ) return false;
return true;
}
void CFXDecal::CalculateCrossPoint ( vec3_t &in_vertex,
vec3_t &in_result )
{
float recip = 1.0f / m_light [2];
in_result [0] = in_vertex [0] - m_light [0] * recip * in_vertex [2];
in_result [1] = in_vertex [1] - m_light [1] * recip * in_vertex [2];
in_result [2] = 0.0f;
}
inline void CFXDecal::CalculateNewTexCoords ( vec3_t in_vertex [],
int in_vtxIndex )
{
m_vtxBuffer [in_vtxIndex ].tu = ( in_vertex [0][0] - ( - m_halfLength ) ) / ( 2.0f * m_halfLength );
m_vtxBuffer [in_vtxIndex ].tv = ( in_vertex [0][1] - ( - m_halfLength ) ) / ( 2.0f * m_halfLength );
m_vtxBuffer [in_vtxIndex + 1].tu = ( in_vertex [1][0] - ( - m_halfLength ) ) / ( 2.0f * m_halfLength );
m_vtxBuffer [in_vtxIndex + 1].tv = ( in_vertex [1][1] - ( - m_halfLength ) ) / ( 2.0f * m_halfLength );
m_vtxBuffer [in_vtxIndex + 2].tu = ( in_vertex [2][0] - ( - m_halfLength ) ) / ( 2.0f * m_halfLength );
m_vtxBuffer [in_vtxIndex + 2].tv = ( in_vertex [2][1] - ( - m_halfLength ) ) / ( 2.0f * m_halfLength );
}
int CFXDecal::CopyVertex ( void *in_pointer )
{
memcpy ( in_pointer, m_vtxBuffer, sizeof(shadow_vertex_t) * m_numVertices );
return m_numVertices;
}
int CFXDecal::GetVertexSize ()
{
return m_numVertices;
}
void CFXDecal::Initialize ()
{
memset ( m_vtxBuffer, 0, sizeof(m_vtxBuffer) );
m_numVertices = 0;
}
| C++ |
#include "frustum.h"
void SetPlaneSignbits( plane_t *out )
{
int bits, j;
bits = 0;
for( j = 0 ; j < 3 ; j++ )
{
if( out->normal[j] < 0 )
{
bits |= 1<<j;
}
}
out->signBits = bits;
}
#if !(defined __linux__ && defined __i386__ && !defined C_ONLY)
#if defined __LCC__ || defined C_ONLY || !id386
int BoxOnPlaneSide( vec3_t emins , vec3_t emaxs , plane_t *p )
{
float dist1, dist2;
int sides;
if( p->type < 3 )
{
if( p->dist <= emins[p->type] )
return 1;
if( p->dist >= emaxs[p->type] )
return 2;
return 3;
}
switch( p->signBits )
{
case 0:
dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
dist2 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
break;
case 1:
dist1 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
break;
case 2:
dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
dist2 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
break;
case 3:
dist1 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
break;
case 4:
dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
dist2 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
break;
case 5:
dist1 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emins[2];
dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emaxs[2];
break;
case 6:
dist1 = p->normal[0]*emaxs[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
dist2 = p->normal[0]*emins[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
break;
case 7:
dist1 = p->normal[0]*emins[0] + p->normal[1]*emins[1] + p->normal[2]*emins[2];
dist2 = p->normal[0]*emaxs[0] + p->normal[1]*emaxs[1] + p->normal[2]*emaxs[2];
break;
default:
dist1 = dist2 = 0;
break;
}
sides = 0;
if( dist1 >= p->dist )
sides = 1;
if( dist2 < p->dist )
sides |= 2;
return sides;
}
#else
#pragma warning( disable: 4035 )
#define dword unsigned int
__declspec( naked ) int BoxOnPlaneSide( vec3_t emins, vec3_t emaxs, plane_t *p)
{
static int bops_initialized;
static int Ljmptab[8];
__asm {
push ebx
cmp bops_initialized, 1
je initialized
mov bops_initialized, 1
mov Ljmptab[0*4], offset Lcase0
mov Ljmptab[1*4], offset Lcase1
mov Ljmptab[2*4], offset Lcase2
mov Ljmptab[3*4], offset Lcase3
mov Ljmptab[4*4], offset Lcase4
mov Ljmptab[5*4], offset Lcase5
mov Ljmptab[6*4], offset Lcase6
mov Ljmptab[7*4], offset Lcase7
initialized:
mov edx,dword ptr[4+12+esp]
mov ecx,dword ptr[4+4+esp]
xor eax,eax
mov ebx,dword ptr[4+8+esp]
mov al,byte ptr[17+edx]
cmp al,8
jge Lerror
fld dword ptr[0+edx]
fld st(0)
jmp dword ptr[Ljmptab+eax*4]
Lcase0:
fmul dword ptr[ebx]
fld dword ptr[0+4+edx]
fxch st(2)
fmul dword ptr[ecx]
fxch st(2)
fld st(0)
fmul dword ptr[4+ebx]
fld dword ptr[0+8+edx]
fxch st(2)
fmul dword ptr[4+ecx]
fxch st(2)
fld st(0)
fmul dword ptr[8+ebx]
fxch st(5)
faddp st(3),st(0)
fmul dword ptr[8+ecx]
fxch st(1)
faddp st(3),st(0)
fxch st(3)
faddp st(2),st(0)
jmp LSetSides
Lcase1:
fmul dword ptr[ecx]
fld dword ptr[0+4+edx]
fxch st(2)
fmul dword ptr[ebx]
fxch st(2)
fld st(0)
fmul dword ptr[4+ebx]
fld dword ptr[0+8+edx]
fxch st(2)
fmul dword ptr[4+ecx]
fxch st(2)
fld st(0)
fmul dword ptr[8+ebx]
fxch st(5)
faddp st(3),st(0)
fmul dword ptr[8+ecx]
fxch st(1)
faddp st(3),st(0)
fxch st(3)
faddp st(2),st(0)
jmp LSetSides
Lcase2:
fmul dword ptr[ebx]
fld dword ptr[0+4+edx]
fxch st(2)
fmul dword ptr[ecx]
fxch st(2)
fld st(0)
fmul dword ptr[4+ecx]
fld dword ptr[0+8+edx]
fxch st(2)
fmul dword ptr[4+ebx]
fxch st(2)
fld st(0)
fmul dword ptr[8+ebx]
fxch st(5)
faddp st(3),st(0)
fmul dword ptr[8+ecx]
fxch st(1)
faddp st(3),st(0)
fxch st(3)
faddp st(2),st(0)
jmp LSetSides
Lcase3:
fmul dword ptr[ecx]
fld dword ptr[0+4+edx]
fxch st(2)
fmul dword ptr[ebx]
fxch st(2)
fld st(0)
fmul dword ptr[4+ecx]
fld dword ptr[0+8+edx]
fxch st(2)
fmul dword ptr[4+ebx]
fxch st(2)
fld st(0)
fmul dword ptr[8+ebx]
fxch st(5)
faddp st(3),st(0)
fmul dword ptr[8+ecx]
fxch st(1)
faddp st(3),st(0)
fxch st(3)
faddp st(2),st(0)
jmp LSetSides
Lcase4:
fmul dword ptr[ebx]
fld dword ptr[0+4+edx]
fxch st(2)
fmul dword ptr[ecx]
fxch st(2)
fld st(0)
fmul dword ptr[4+ebx]
fld dword ptr[0+8+edx]
fxch st(2)
fmul dword ptr[4+ecx]
fxch st(2)
fld st(0)
fmul dword ptr[8+ecx]
fxch st(5)
faddp st(3),st(0)
fmul dword ptr[8+ebx]
fxch st(1)
faddp st(3),st(0)
fxch st(3)
faddp st(2),st(0)
jmp LSetSides
Lcase5:
fmul dword ptr[ecx]
fld dword ptr[0+4+edx]
fxch st(2)
fmul dword ptr[ebx]
fxch st(2)
fld st(0)
fmul dword ptr[4+ebx]
fld dword ptr[0+8+edx]
fxch st(2)
fmul dword ptr[4+ecx]
fxch st(2)
fld st(0)
fmul dword ptr[8+ecx]
fxch st(5)
faddp st(3),st(0)
fmul dword ptr[8+ebx]
fxch st(1)
faddp st(3),st(0)
fxch st(3)
faddp st(2),st(0)
jmp LSetSides
Lcase6:
fmul dword ptr[ebx]
fld dword ptr[0+4+edx]
fxch st(2)
fmul dword ptr[ecx]
fxch st(2)
fld st(0)
fmul dword ptr[4+ecx]
fld dword ptr[0+8+edx]
fxch st(2)
fmul dword ptr[4+ebx]
fxch st(2)
fld st(0)
fmul dword ptr[8+ecx]
fxch st(5)
faddp st(3),st(0)
fmul dword ptr[8+ebx]
fxch st(1)
faddp st(3),st(0)
fxch st(3)
faddp st(2),st(0)
jmp LSetSides
Lcase7:
fmul dword ptr[ecx]
fld dword ptr[0+4+edx]
fxch st(2)
fmul dword ptr[ebx]
fxch st(2)
fld st(0)
fmul dword ptr[4+ecx]
fld dword ptr[0+8+edx]
fxch st(2)
fmul dword ptr[4+ebx]
fxch st(2)
fld st(0)
fmul dword ptr[8+ecx]
fxch st(5)
faddp st(3),st(0)
fmul dword ptr[8+ebx]
fxch st(1)
faddp st(3),st(0)
fxch st(3)
faddp st(2),st(0)
LSetSides:
faddp st(2),st(0)
fcomp dword ptr[12+edx]
xor ecx,ecx
fnstsw ax
fcomp dword ptr[12+edx]
and ah,1
xor ah,1
add cl,ah
fnstsw ax
and ah,1
add ah,ah
add cl,ah
pop ebx
mov eax,ecx
ret
Lerror:
int 3
}
}
#pragma warning( default: 4035 )
#endif
#endif
#define BOX_ON_PLANE_SIDE(emins, emaxs, p) \
(((p)->type < 3)? \
( \
((p)->dist <= (emins)[(p)->type])? \
1 \
: \
( \
((p)->dist >= (emaxs)[(p)->type])?\
2 \
: \
3 \
) \
) \
: \
BoxOnPlaneSide( (emins), (emaxs), (p)))
void CFrustum::Setup( vec3_t angles , vec3_t position , projectionparam_t *projectParm )
{
vec3_t rotate , normal , znear;
float halfFov;
rotate[ YAW ] = angles[ YAW ];
rotate[ PITCH ] = angles[ PITCH ];
AngleToVector( rotate , normal );
VectorScale( znear , normal , projectParm->znear );
VectorAdd( znear , znear , position );
VectorCopy( planes[ FRUSTUM_NEAR_PLAIN ].normal , normal );
planes[ FRUSTUM_NEAR_PLAIN ].dist = VectorDotProduct( normal , znear );
planes[ FRUSTUM_NEAR_PLAIN ].type = PlaneTypeForNormal( normal );
SetPlaneSignbits( &planes[ FRUSTUM_NEAR_PLAIN ] );
halfFov = projectParm->fov / 2.0f / projectParm->aspect;
rotate[ YAW ] = angles[ YAW ];
rotate[ PITCH ] = angles[ PITCH ] - ( 90.0f - halfFov );
AngleToVector( rotate , normal );
VectorCopy( planes[ FRUSTUM_TOP_PLAIN ].normal , normal );
planes[ FRUSTUM_TOP_PLAIN ].dist = VectorDotProduct( normal , position );
planes[ FRUSTUM_TOP_PLAIN ].type = PlaneTypeForNormal( normal );
SetPlaneSignbits( &planes[ FRUSTUM_TOP_PLAIN ] );
rotate[ YAW ] = angles[ YAW ];
rotate[ PITCH ] = angles[ PITCH ] + ( 90.0f - halfFov );
AngleToVector( rotate , normal );
VectorCopy( planes[ FRUSTUM_BOTTOM_PLAIN ].normal , normal );
planes[ FRUSTUM_BOTTOM_PLAIN ].dist = VectorDotProduct( normal , position );
planes[ FRUSTUM_BOTTOM_PLAIN ].type = PlaneTypeForNormal( normal );
SetPlaneSignbits( &planes[ FRUSTUM_BOTTOM_PLAIN ] );
halfFov = projectParm->fov / 2.0f;
rotate[ YAW ] = angles[ YAW ] + ( 90.0f - halfFov );
rotate[ PITCH ] = angles[ PITCH ];
AngleToVector( rotate , normal );
VectorCopy( planes[ FRUSTUM_LEFT_PLAIN ].normal , normal );
planes[ FRUSTUM_LEFT_PLAIN ].dist = VectorDotProduct( normal , position );
planes[ FRUSTUM_LEFT_PLAIN ].type = PlaneTypeForNormal( normal );
SetPlaneSignbits( &planes[ FRUSTUM_LEFT_PLAIN ] );
rotate[ YAW ] = angles[ YAW ] - ( 90.0f - halfFov );
rotate[ PITCH ] = angles[ PITCH ];
AngleToVector( rotate , normal );
VectorCopy( planes[ FRUSTUM_RIGHT_PLAIN ].normal , normal );
planes[ FRUSTUM_RIGHT_PLAIN ].dist = VectorDotProduct( normal , position );
planes[ FRUSTUM_RIGHT_PLAIN ].type = PlaneTypeForNormal( normal );
SetPlaneSignbits( &planes[ FRUSTUM_RIGHT_PLAIN ] );
}
int CFrustum::Cull( vec3_t mins , vec3_t maxs )
{
int side;
side = BOX_ON_PLANE_SIDE( mins , maxs , &planes[ FRUSTUM_NEAR_PLAIN ] );
if( side == 2 ) return true;
if( side != 1 ) return false;
side = BOX_ON_PLANE_SIDE( mins , maxs , &planes[ FRUSTUM_LEFT_PLAIN ] );
if( side == 2 ) return true;
if( side != 1 ) return false;
side = BOX_ON_PLANE_SIDE( mins , maxs , &planes[ FRUSTUM_RIGHT_PLAIN ] );
if( side == 2 ) return true;
if( side != 1 ) return false;
side = BOX_ON_PLANE_SIDE( mins , maxs , &planes[ FRUSTUM_TOP_PLAIN ] );
if( side == 2 ) return true;
if( side != 1 ) return false;
side = BOX_ON_PLANE_SIDE( mins , maxs , &planes[ FRUSTUM_BOTTOM_PLAIN ] );
if( side == 2 ) return true;
if( side != 1 ) return false;
return false;
}
int CFrustum::Cull_Exact( vec3_t mins , vec3_t maxs )
{
int i;
float* p;
float XxMinX , YxMinY , ZxMinZ , XxMaxX , YxMaxY , ZxMaxZ , dist;
for( i = 0 ; i < 5 ; ++i )
{
p = planes[i].normal;
XxMinX = p[0] * mins[0]; XxMaxX = p[0] * maxs[0];
YxMinY = p[1] * mins[1]; YxMaxY = p[1] * maxs[1];
ZxMinZ = p[2] * mins[2]; ZxMaxZ = p[2] * maxs[2];
dist = planes[i].dist;
if( XxMinX + YxMinY + ZxMinZ - dist > 0 ) continue;
if( XxMaxX + YxMinY + ZxMinZ - dist > 0 ) continue;
if( XxMinX + YxMaxY + ZxMinZ - dist > 0 ) continue;
if( XxMaxX + YxMaxY + ZxMinZ - dist > 0 ) continue;
if( XxMinX + YxMinY + ZxMaxZ - dist > 0 ) continue;
if( XxMaxX + YxMinY + ZxMaxZ - dist > 0 ) continue;
if( XxMinX + YxMaxY + ZxMaxZ - dist > 0 ) continue;
if( XxMaxX + YxMaxY + ZxMaxZ - dist > 0 ) continue;
return true;
}
return false;
}
| C++ |
#include <d3dx8.h>
#include "display.h"
#include "d3ddevice.h"
#include "../common/d3dapp.h"
#include "../math/math.h"
CDisplay g_display;
CDisplay::CDisplay()
{
m_gammaRampType = 1;
}
CDisplay::~CDisplay()
{
}
void CDisplay::SetupGamma()
{
D3DGAMMARAMP ramp;
for(int i = 0; i < 256; i++)
{
int x = fast_round( (float)( ( m_DisplayParams.Contrast + 0.5 ) *
pow( i/255.0, 1.0/m_DisplayParams.Gamma ) * 65535.0 +
( m_DisplayParams.Brightness - 0.5 ) * 32768.0 -
m_DisplayParams.Contrast * 32768.0 + 16384.0 ) );
WORD val = x < 0 ? 0 : x<65535 ? x : 65535;
ramp.red[i] = val;
ramp.green[i] = val;
ramp.blue[i] = val;
}
#ifdef _DEBUG
return;
#endif
switch( m_gammaRampType )
{
case 1:
g_d3dDevice.GetD3DDevice()->SetGammaRamp( D3DSGR_CALIBRATE, &ramp );
break;
case 2:
{
HDC hDC;
hDC = GetDC( NULL );
SetDeviceGammaRamp( hDC, &ramp );
ReleaseDC( NULL, hDC );
}
break;
default:
g_d3dDevice.GetD3DDevice()->SetGammaRamp( D3DSGR_CALIBRATE, &ramp );
break;
}
}
| C++ |
#if !defined(AFX_SCRIPT_H__6A3BE47E_7231_49B1_B9CC_C88DF5B89578__INCLUDED_)
#define AFX_SCRIPT_H__6A3BE47E_7231_49B1_B9CC_C88DF5B89578__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include <windows.h>
#include "core_def.h"
class CScript
{
public:
char m_name[ GTH_MAX_SIZE_FILENAME ];
char m_token[ GTH_MAX_SIZE_TOKEN ];
CScript();
virtual ~CScript();
void Reset();
int MatchToken( char *match );
void SkipBracedSection();
int GetCurrParseLine();
void BeginParse();
char *GetName();
void SkipLine();
int SkipToken();
int SetOffset( int offset );
char *GetCurrToken();
char *GetNextToken();
char *GetNextToken(int allowNewline);
int Load( char *fName );
int Load( char *fName , DWORD size , BYTE *data );
int GetCSVToken( char token[] );
protected:
BYTE *m_buffer;
int m_lines;
BYTE *m_prevOffset;
BYTE *m_baseOffset;
BYTE *m_currOffset;
DWORD m_bufferSize;
int SkipSpace();
};
extern CScript g_script;
#endif
| C++ |
#if !defined(AFX_CAMERA_H__7F4A10A7_1E7F_4FA6_97B6_01AEE4AEDCC8__INCLUDED_)
#define AFX_CAMERA_H__7F4A10A7_1E7F_4FA6_97B6_01AEE4AEDCC8__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "../math/math.h"
#include "bsp.h"
#define CAMERA_VIEWTYPE_PLAYER_BACK 0x00000000
#define CAMERA_VIEWTYPE_PLAYER_FRONT 0x00000001
#define CAMERA_VIEWTYPE_PLAYER_RIGHT 0x00000002
#define CAMERA_VIEWTYPE_PLAYER_LEFT 0x00000004
#define CAMERA_VIEWTYPE_QUATER_VIEW 0x00000010
#define CAMERA_VIEWTYPE_TOP_VIEW 0x00000020
#define GTH_PROJECT_NEAR_PLANE 10.0f
class CCamera
{
public:
CBSP* m_world;
matrix4x4_t m_projMat;
matrix4x4_t m_viewMat;
matrix4x4_t m_worldMat;
matrix4x4_t m_transMat;
matrix4x4_t m_envMat;
matrix4x4_t m_invProjMat;
matrix4x4_t m_invViewMat;
matrix4x4_t m_invWorldMat;
matrix4x4_t m_invTransMat;
vec3_t m_position;
vec3_t m_angles;
vec3_t m_forward;
vec3_t m_right;
vec3_t m_up;
float m_distance;
int m_isThirdPerson;
int m_autoFollow;
float m_characterAngle;
int m_viewType;
float m_minCamDist;
float m_maxCamDist;
vec3_t m_characterPos;
CFrustum m_frustum;
projectionparam_t m_projectParm;
CCamera();
virtual ~CCamera();
void SetWorldModel( CBSP *world ) { m_world = world; }
void SetupVectors() { AngleVectors( m_angles , m_forward , m_right , m_up ); }
void SetMinCameraDistance( float minDist ) { m_minCamDist = minDist; }
void SetMaxCameraDistance( float maxDist ) { m_maxCamDist = maxDist; }
void SetPosition( vec3_t pos ) { VectorCopy( m_position , pos ); }
void SetAngles( vec3_t angles );
void SetupMatrices( int isFrustumSetup );
void SetFovY(double fovy, double aspect, double znear, double zfar);
void SetupViewPort( int x , int y , int width , int height , float minZ , float maxZ );
void AdjustCameraAngle( vec3_t pos , vec3_t angles , float elapsedTime );
void AdjustCamera( vec3_t pos , vec3_t angles );
int CheckCameraPos( vec3_t pos , float dist , vec3_t angles );
void Zoom( int value );
void RotateAngles( vec3_t rotate );
inline void AdjustAngles();
void SetAuto( int autoFollow ) { m_autoFollow = autoFollow; }
int IsAuto() { return m_autoFollow; }
matrix4x4_t *GetTransformMatrix() { return &m_transMat; }
matrix4x4_t *GetInverseTransformMatrix() { return &m_invTransMat; }
matrix4x4_t *GetEnvironmentMatrix() { return &m_envMat; }
void GetFwdVector( vec3_t vec );
void GetRightVector( vec3_t vec );
void GetUpVector( vec3_t vec );
void Reset();
void SetViewType( int type );
void SetProjectParameter( float znear , float zfar );
};
extern CCamera g_camera;
#endif
| C++ |
#if !defined(AFX_D3DTEXTUREMNG_H__B5840EDF_D75E_45F5_9D27_E8C7AC93F289__INCLUDED_)
#define AFX_D3DTEXTUREMNG_H__B5840EDF_D75E_45F5_9D27_E8C7AC93F289__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include <d3dx8.h>
#include "core_def.h"
#include "ResManager.h"
#define MAX_SIZE_TEXTURE 2902
#define MAX_SIZE_FILENAME 128
class CTextureResource : public BaseResource
{
public :
char m_name[GTH_MAX_SIZE_FILENAME];
int m_owner;
int m_loaded;
int m_width;
int m_height;
int m_size;
int m_bits;
int m_mipLevel;
int m_hasAlpha;
BYTE *m_data;
DWORD m_minFilter;
DWORD m_magFilter;
DWORD m_mipFilter;
DWORD m_addrMode;
LPDIRECT3DTEXTURE8 m_d3dTex;
CTextureResource();
virtual ~CTextureResource();
bool UploadTexture();
void Clear()
{
m_d3dTex = NULL;
m_data = NULL;
}
bool Create( char *fname, int iSize );
bool Register( char *fname, int iSize )
{
m_size = iSize;
return true ;
}
virtual bool Recreate();
virtual void Dispose()
{
GTH_SAFE_FREE( m_data );
GTH_SAFE_RELEASE( m_d3dTex );
}
size_t GetSize()
{
if( m_d3dTex ) return m_size;
else return 0;
}
bool IsDisposed()
{
if( m_d3dTex ) return false;
else return true;
}
};
#define GTH_TEXTURE_QUALITY_LOW 1
#define GTH_TEXTURE_QUALITY_HIGH 0
class CD3DTextureMng
{
public:
CD3DTextureMng();
virtual ~CD3DTextureMng();
CTextureResource m_textures[ MAX_SIZE_TEXTURE ];
CResManager m_resManager;
int m_numTextures;
DWORD m_whiteImage[ 16 * 16 * 4 ];
int m_whiteImageRef;
int m_texQuality;
size_t m_nTextureMaxMemory;
unsigned long m_textureRscSize;
void SetTextureQuality( int quality ) { m_texQuality = quality; }
LPDIRECT3DTEXTURE8 GetD3DTexture( int texRef );
void Release();
void Release( int owner );
void Release( char *name , int owner );
void Release( int idxTex , int owner );
void Restore();
int GetWhiteImageRef() { return m_whiteImageRef; }
void AddWhiteImage();
int Search( char *name , int owner );
int Add( char *name , int owner , int size = 0 , BYTE *data = NULL
, int bits = 32 , int wrap = true , int mipLevel = 4 , int hasAlpha = false
, int width = 0 , int height = 0 );
};
extern CD3DTextureMng g_texMng;
#endif
| C++ |
#include "bsp.h"
#include "d3drender.h"
#define SKY_SIDE_SIZE 6
#define SIDE_DIV_SIZE 11
#define SPHERE_RAD 10.0
#define EYE_RAD 9.0
#define SCALE_S 4.0f
#define SCALE_T 4.0f
#define VERTEX_SIZE_ENVIRON_SKY ( 4 * 6 )
#define ELEMENT_SIZE_ENVIRON_SKY ( 6 * 6 )
#define SIDE_VERTEX_SIZE_SKY ( SIDE_DIV_SIZE * SIDE_DIV_SIZE )
#define SIDE_ELEMENT_SIZE_SKY ( ( SIDE_DIV_SIZE - 1 ) * ( SIDE_DIV_SIZE - 1 ) * 6 )
#define SKY_SIZE 2.0
#include <assert.h>
#define SIDE_SKY 20
#define PLANETRADIUS 280.0f
#define ATMOSPHERERADIUS 295.0f
void CBSP::CalcSkySize( int shaderFlag , int *numVerts , int *numElems )
{
if( shaderFlag & SHADER_SKY_ENVIRON )
{
*numVerts = VERTEX_SIZE_ENVIRON_SKY;
*numElems = ELEMENT_SIZE_ENVIRON_SKY;
}
else
{
if(g_d3dRender.m_bFog)
{
*numVerts = (SIDE_SKY + 1) * (SIDE_SKY + 1);
*numElems = SIDE_SKY * SIDE_SKY * 6;
}
else
{
*numVerts = SIDE_VERTEX_SIZE_SKY * SKY_SIDE_SIZE;
*numElems = SIDE_ELEMENT_SIZE_SKY * SKY_SIDE_SIZE;
}
}
}
void CBSP::GenSky( face_t *face, int baseVB, int shaderFlag, vertex_t *ptrStaticVB, WORD *ptrStaticEB )
{
int i , u , v;
vertex_t *ptrVB = ptrStaticVB;
WORD *ptrEB = ptrStaticEB;
if( shaderFlag & SHADER_SKY_ENVIRON )
{
GenEnvSkyBox( ptrVB, ptrEB, baseVB );
}
else
{
if(g_d3dRender.m_bFog)
{
GenSkyBox_Lee( ptrVB );
}
else
{
GenSkyBox_Neo( ptrVB );
}
}
if( shaderFlag & SHADER_SKY_ENVIRON )
{
face->sizeVB = VERTEX_SIZE_ENVIRON_SKY;
face->sizeEB = ELEMENT_SIZE_ENVIRON_SKY;
}
else
{
if(g_d3dRender.m_bFog)
{
int divisions = (int)sqrt(SIDE_SKY * SIDE_SKY);
int index = 0;
for ( int z = 0; z < divisions; z++)
{
for (int x = 0; x < divisions; x++)
{
int startvert = (z * (divisions+1) + x);
*ptrEB++ = (WORD)(baseVB + startvert);
*ptrEB++ = (WORD)(baseVB + startvert + 1);
*ptrEB++ = (WORD)(baseVB + startvert + divisions + 1);
*ptrEB++ = (WORD)(baseVB + startvert + 1);
*ptrEB++ = (WORD)(baseVB + startvert + divisions + 2);
*ptrEB++ = (WORD)(baseVB + startvert + divisions + 1);
}
}
face->sizeVB = (SIDE_SKY + 1) * (SIDE_SKY + 1);
face->sizeEB = SIDE_SKY * SIDE_SKY * 6;
}
else
{
for( i = 0 ; i < SKY_SIDE_SIZE ; i++ )
{
for( v = 0 ; v < SIDE_DIV_SIZE - 1 ; v++ )
{
for( u = 0 ; u < SIDE_DIV_SIZE - 1 ; u++ )
{
*ptrEB++ = (WORD) ( baseVB + v * SIDE_DIV_SIZE + u );
*ptrEB++ = (WORD) ( baseVB + (v+1) * SIDE_DIV_SIZE + u );
*ptrEB++ = (WORD) ( baseVB + v * SIDE_DIV_SIZE + u + 1 );
*ptrEB++ = (WORD) ( baseVB + v * SIDE_DIV_SIZE + u + 1 );
*ptrEB++ = (WORD) ( baseVB + (v+1) * SIDE_DIV_SIZE + u );
*ptrEB++ = (WORD) ( baseVB + (v+1) * SIDE_DIV_SIZE + u + 1 );
}
}
baseVB += SIDE_VERTEX_SIZE_SKY;
}
face->sizeVB = SIDE_VERTEX_SIZE_SKY * SKY_SIDE_SIZE;
face->sizeEB = SIDE_ELEMENT_SIZE_SKY * SKY_SIDE_SIZE;
}
}
}
void CBSP::GenEnvSkyBox( vertex_t *ptrVB , WORD *ptrEB , int baseVB )
{
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , -1.0f , 1.0f , -1.0f );
Vector2Set( ptrVB->texUV , 0.0f , 0.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , 1.0f , 1.0f , -1.0f );
Vector2Set( ptrVB->texUV , 0.0f , 1.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , 1.0f , -1.0f , -1.0f );
Vector2Set( ptrVB->texUV , 1.0f , 1.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , -1.0f , -1.0f , -1.0f );
Vector2Set( ptrVB->texUV , 1.0f , 0.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , -1.0f , 1.0f , 1.0f );
Vector2Set( ptrVB->texUV , 0.0f , 0.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , -1.0f , -1.0f , 1.0f );
Vector2Set( ptrVB->texUV , 0.0f , 1.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , 1.0f , -1.0f , 1.0f );
Vector2Set( ptrVB->texUV , 1.0f , 0.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , 1.0f , 1.0f , 1.0f );
Vector2Set( ptrVB->texUV , 1.0f , 1.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , -1.0f , 1.0f , 1.0f );
Vector2Set( ptrVB->texUV , 0.0f , 0.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , 1.0f , 1.0f , 1.0f );
Vector2Set( ptrVB->texUV , 0.0f , 1.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , 1.0f , 1.0f , -1.0f );
Vector2Set( ptrVB->texUV , 1.0f , 0.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , -1.0f , 1.0f , -1.0f );
Vector2Set( ptrVB->texUV , 1.0f , 1.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , -1.0f , -1.0f , 1.0f );
Vector2Set( ptrVB->texUV , 0.0f , 0.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , -1.0f , -1.0f , -1.0f );
Vector2Set( ptrVB->texUV , 0.0f , 1.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , 1.0f , -1.0f , -1.0f );
Vector2Set( ptrVB->texUV , 1.0f , 0.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , 1.0f , -1.0f , 1.0f );
Vector2Set( ptrVB->texUV , 1.0f , 1.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , 1.0f , 1.0f , -1.0f );
Vector2Set( ptrVB->texUV , 0.0f , 0.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , 1.0f , 1.0f , 1.0f );
Vector2Set( ptrVB->texUV , 0.0f , 1.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , 1.0f , -1.0f , 1.0f );
Vector2Set( ptrVB->texUV , 1.0f , 0.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , 1.0f , -1.0f , -1.0f );
Vector2Set( ptrVB->texUV , 1.0f , 1.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , -1.0f , 1.0f , -1.0f );
Vector2Set( ptrVB->texUV , 0.0f , 0.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , -1.0f , -1.0f , -1.0f );
Vector2Set( ptrVB->texUV , 0.0f , 1.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , -1.0f , -1.0f , 1.0f );
Vector2Set( ptrVB->texUV , 1.0f , 0.0f ); ptrVB++;
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorSet( ptrVB->point , -1.0f , 1.0f , 1.0f );
Vector2Set( ptrVB->texUV , 1.0f , 1.0f ); ptrVB++;
*ptrEB++ = (WORD) ( baseVB + 0+0 ); *ptrEB++ = (WORD) ( baseVB + 0+3 ); *ptrEB++ = (WORD) ( baseVB + 0+2 );
*ptrEB++ = (WORD) ( baseVB + 0+2 ); *ptrEB++ = (WORD) ( baseVB + 0+1 ); *ptrEB++ = (WORD) ( baseVB + 0+0 );
*ptrEB++ = (WORD) ( baseVB + 4+0 ); *ptrEB++ = (WORD) ( baseVB + 4+3 ); *ptrEB++ = (WORD) ( baseVB + 4+2 );
*ptrEB++ = (WORD) ( baseVB + 4+2 ); *ptrEB++ = (WORD) ( baseVB + 4+1 ); *ptrEB++ = (WORD) ( baseVB + 4+0 );
*ptrEB++ = (WORD) ( baseVB + 8+0 ); *ptrEB++ = (WORD) ( baseVB + 8+3 ); *ptrEB++ = (WORD) ( baseVB + 8+2 );
*ptrEB++ = (WORD) ( baseVB + 8+2 ); *ptrEB++ = (WORD) ( baseVB + 8+1 ); *ptrEB++ = (WORD) ( baseVB + 8+0 );
*ptrEB++ = (WORD) ( baseVB +12+0 ); *ptrEB++ = (WORD) ( baseVB +12+3 ); *ptrEB++ = (WORD) ( baseVB +12+2 );
*ptrEB++ = (WORD) ( baseVB +12+2 ); *ptrEB++ = (WORD) ( baseVB +12+1 ); *ptrEB++ = (WORD) ( baseVB +12+0 );
*ptrEB++ = (WORD) ( baseVB +16+0 ); *ptrEB++ = (WORD) ( baseVB +16+3 ); *ptrEB++ = (WORD) ( baseVB +16+2 );
*ptrEB++ = (WORD) ( baseVB +16+2 ); *ptrEB++ = (WORD) ( baseVB +16+1 ); *ptrEB++ = (WORD) ( baseVB +16+0 );
*ptrEB++ = (WORD) ( baseVB +20+0 ); *ptrEB++ = (WORD) ( baseVB +20+3 ); *ptrEB++ = (WORD) ( baseVB +20+2 );
*ptrEB++ = (WORD) ( baseVB +20+2 ); *ptrEB++ = (WORD) ( baseVB +20+1 ); *ptrEB++ = (WORD) ( baseVB +20+0 );
}
void CBSP::GenSkyBox( vertex_t *ptrVB )
{
vec3_t orig, drow, dcol;
float startXY = 1.0f;
float stepXY = 2.0f / ( SIDE_DIV_SIZE - 1 );
float startZ = 0.5f;
float stepZ = 1.0f / ( SIDE_DIV_SIZE - 1 );
orig[0] = -startXY;
orig[1] = startXY;
orig[2] = startZ;
drow[0] = 0.0;
drow[1] = -stepXY;
drow[2] = 0.0;
dcol[0] = stepXY;
dcol[1] = 0.0;
dcol[2] = 0.0;
GenSkyBoxSide( SKYBOX_TOP , orig , drow , dcol , ptrVB );
ptrVB += SIDE_DIV_SIZE * SIDE_DIV_SIZE;
orig[0] = startXY;
orig[1] = startXY;
orig[2] = startZ;
drow[0] = 0.0;
drow[1] = 0.0;
drow[2] = -stepZ;
dcol[0] = -stepXY;
dcol[1] = 0.0;
dcol[2] = 0.0;
GenSkyBoxSide( SKYBOX_FRONT , orig , drow , dcol , ptrVB );
ptrVB += SIDE_DIV_SIZE * SIDE_DIV_SIZE;
orig[0] = startXY;
orig[1] = -startXY;
orig[2] = startZ;
drow[0] = 0.0;
drow[1] = 0.0;
drow[2] = -stepZ;
dcol[0] = 0.0;
dcol[1] = stepXY;
dcol[2] = 0.0;
GenSkyBoxSide( SKYBOX_RIGHT , orig , drow , dcol , ptrVB );
ptrVB += SIDE_DIV_SIZE * SIDE_DIV_SIZE;
orig[0] = -startXY;
orig[1] = -startXY;
orig[2] = startZ;
drow[0] = 0.0;
drow[1] = 0.0;
drow[2] = -stepZ;
dcol[0] = stepXY;
dcol[1] = 0.0;
dcol[2] = 0.0;
GenSkyBoxSide( SKYBOX_BACK , orig , drow , dcol , ptrVB );
ptrVB += SIDE_DIV_SIZE * SIDE_DIV_SIZE;
orig[0] = -startXY;
orig[1] = startXY;
orig[2] = startZ;
drow[0] = 0.0;
drow[1] = 0.0;
drow[2] = -stepZ;
dcol[0] = 0.0;
dcol[1] = -stepXY;
dcol[2] = 0.0;
GenSkyBoxSide( SKYBOX_LEFT , orig , drow , dcol , ptrVB );
}
void CBSP::GenSkyBoxSide( int side, vec3_t orig, vec3_t drow, vec3_t dcol, vertex_t * ptrVB )
{
vec3_t pos, w, row, *v;
vec2_t *tc;
float p;
int r, c;
float d, b, t;
d = EYE_RAD;
b = SPHERE_RAD;
VectorCopy( row , orig );
for (r = 0; r < SIDE_DIV_SIZE; ++r)
{
VectorCopy( pos , row );
for (c = 0; c < SIDE_DIV_SIZE; ++c)
{
v = &ptrVB->point;
tc = &ptrVB->texUV;
VectorCopy( (*v) , pos );
VectorCopy( w , pos );
p = (float) sqrt( VectorDotProduct(w, w) );
w[0] /= p;
w[1] /= p;
w[2] /= p;
t = (float) sqrt(d*d*(w[2]*w[2]-1.0) + b*b) - d*w[2];
w[0] *= t;
w[1] *= t;
(*tc)[0] = w[0] / (2.0f * SCALE_S);
(*tc)[1] = w[1] / (2.0f * SCALE_T);
ColorSet( ptrVB->diffuse , 255 , 255 , 255 , 255 );
VectorAdd( pos , pos , dcol );
ptrVB++;
}
VectorAdd( row , row , drow );
}
}
void CBSP::GenSkyBox_Neo ( vertex_t *in_vb )
{
vec3_t baseaxis[18] =
{
1, 0, 0, 0,-1, 0, 0, 0, 1,
0, 0, 1, 0, 1, 0, 1, 0, 0,
0,-1, 0, -1, 0, 0, 0, 0, 1,
-1, 0, 0, 0, 1, 0, 0, 0, 1,
0, 0,-1, 0, 1, 0, -1, 0, 0,
0, 1, 0, 1, 0, 0, 0, 0, 1
};
int sideIdx;
for ( sideIdx = 0; \
sideIdx < SKY_SIDE_SIZE; \
++sideIdx )
{
GenSkyVertices( baseaxis[ sideIdx * 3 ], baseaxis[ sideIdx * 3 + 2 ], baseaxis[ sideIdx * 3 + 1 ],
SIDE_DIV_SIZE, SKY_SIZE, &in_vb[ sideIdx * SIDE_DIV_SIZE * SIDE_DIV_SIZE ] );
}
const float SKYHEIGHT = 5.0f;
GenSkyTexCoords( SKYHEIGHT, SKY_SIDE_SIZE * SIDE_DIV_SIZE * SIDE_DIV_SIZE, in_vb );
}
void CBSP::GenSkyVertices ( vec3_t in_forward,
vec3_t in_up,
vec3_t in_right,
int in_numTess,
float in_skySize,
vertex_t *in_vb )
{
float distance = in_skySize / (float)( in_numTess - 1 );
vec3_t origin;
origin[0] = in_forward[0] - in_up[0] - in_right[0];
origin[1] = in_forward[1] - in_up[1] - in_right[1];
origin[2] = in_forward[2] - in_up[2] - in_right[2];
float halfsize = in_skySize * 0.5f;
VectorScale( origin, origin, halfsize );
vec3_t up, right;
VectorCopy( up, in_up );
VectorScale( up, up, distance );
VectorCopy( right, in_right );
VectorScale( right, right, distance );
int rowidx, colidx;
vec3_t vertex;
for ( rowidx = 0; \
rowidx < in_numTess; \
++rowidx )
{
VectorCopy( vertex, origin );
for ( colidx = 0; \
colidx < in_numTess; \
++colidx )
{
VectorCopy( in_vb->point, vertex );
VectorAdd( vertex, vertex, right );
ColorSet( in_vb->diffuse, 255, 255, 255, 255 );
in_vb++;
}
VectorAdd( origin, origin, up );
}
}
void CBSP::GenSkyTexCoords ( float in_skyHeight,
int in_numVtx,
vertex_t *in_vb )
{
const float SKY_RADIUS = 5.25f;
float temp = in_skyHeight * in_skyHeight - SKY_RADIUS * SKY_RADIUS;
int index;
vec3_t direction;
for (index = 0; index < in_numVtx; ++index)
{
VectorCopy( direction, in_vb->point );
float SQRDIST_DIR = VectorDotProduct( direction, direction );
float INTER_A = in_skyHeight * fabsf( direction[2] ) / SQRDIST_DIR;
float INTER_B = temp / SQRDIST_DIR;
float INTER_C = sqrtf( INTER_A * INTER_A - INTER_B ) - INTER_A;
assert( INTER_C > 0.0f );
float height = ( fabsf( direction[2] ) * INTER_C + in_skyHeight ) / SKY_RADIUS;
height = fabsf( height );
if ( height > 1.0f )
height = 1.0f;
float latitude = ( __HALFPI - asinf( height ) ) / __HALFPI;
INTER_C = direction[0] * direction[0] + direction[1] * direction[1];
if ( INTER_C > 0.000001f )
{
INTER_C = 1.0f / sqrtf( INTER_C );
}
in_vb->texUV[0] = 0.5f + direction[0] * latitude * INTER_C * 2.0f;
in_vb->texUV[1] = 1.0f - ( 0.5f + direction[1] * latitude * INTER_C * 2.0f );
in_vb++;
}
}
void CBSP::GenSkyBox_Lee(vertex_t *in_vb)
{
int divisions = (int)sqrt(SIDE_SKY * SIDE_SKY);
float plane_size = 2.0f * (float)sqrt( (ATMOSPHERERADIUS*ATMOSPHERERADIUS) - (PLANETRADIUS*PLANETRADIUS) );
float delta = plane_size / (float)divisions;
float tex_delta1 = 1.0f / (float)divisions;
float tex_delta2 = 1.0f / (float)divisions;
float x_dist = 0.0f;
float z_dist = 0.0f;
float x_height = 0.0f;
float z_height = 0.0f;
float height = 0.0f;
for(int z = 0; z <= divisions; z++)
{
for(int x = 0; x <= divisions; x++)
{
x_dist = (-0.5f * plane_size) + ((float)x * delta);
z_dist = (-0.5f * plane_size) + ((float)z * delta);
x_height = (x_dist * x_dist) / ATMOSPHERERADIUS;
z_height = (z_dist * z_dist) / ATMOSPHERERADIUS;
height = x_height + z_height;
in_vb->point[0] = x_dist * 800;
in_vb->point[2] = (0.0f - height) * 800;
in_vb->point[1] = z_dist * 800;
in_vb->texUV[0] = ((float)x * tex_delta1);
in_vb->texUV[1] = ((float)z * tex_delta1);
ColorSet( in_vb->diffuse, 255, 255, 255, 255 );
in_vb++;
}
}
}
| C++ |
#include "filemng.h"
#include "core_def.h"
#include "../skill/SkillFile.h"
CFileMng g_fileMng;
#include <VECTOR>
typedef std::vector<string> ReadedFileMap;
typedef ReadedFileMap::iterator ReadedFileItor;
ReadedFileMap readedfilemap;
DWORD dupReadedFilesize = 0;
CFileMng::CFileMng()
{
m_basePath[0] = 0;
m_numPackFiles = 0;
m_numFilesInPack = 0;
strcpy( m_dataPath , "data/" );
memset(m_monsterPath, 0, sizeof(m_monsterPath));
strcpy(m_monsterPath, "monster/");
memset(m_NPCPath, 0, sizeof(m_NPCPath));
strcpy(m_NPCPath, "npc/");
memset(m_itemPath,0,sizeof(m_itemPath));
strcpy(m_itemPath, "items/");
memset(m_earthPath,0,sizeof(m_earthPath));
strcpy(m_earthPath, "earth/");
memset(m_waterPath,0,sizeof(m_waterPath));
strcpy(m_waterPath, "water/");
memset(m_occultPath,0,sizeof(m_occultPath));
strcpy(m_occultPath, "occult/");
memset(m_windPath,0,sizeof(m_windPath));
strcpy(m_windPath, "wind/");
}
CFileMng::~CFileMng()
{
packfilemap::iterator i = m_fileMap.begin();
while( i != m_fileMap.end() )
{
if( (*i).second == NULL )
{
i ++;
continue;
}
delete (*i ++).second;
}
m_fileMap.erase( m_fileMap.begin(), m_fileMap.end() );
ClosePackFiles();
}
void CFileMng::ClosePackFiles()
{
for( int i = 0; i < m_numPackFiles; i ++ )
PackFileClose( &m_packFiles[ i ] );
m_numPackFiles = 0;
}
void CFileMng::MakePackFilesMap()
{
int i;
int num;
packfile_t *pf;
packfileinfo_t *pi, *pi_byname;
for( i = 0; i < m_numPackFiles; i ++ )
{
pf = &m_packFiles[i];
for( num = 0; num < (int)pf->gi.number_entry; num ++ )
{
pi = MakeFilesInfo( pf, i, num );
pi_byname = FindSameFilename( pi->fi.name );
if( pi_byname == NULL )
{
RegisterFile( pi->fi.name, pi );
m_numFilesInPack ++;
}
else
{
if( pi->fi.date > pi_byname->fi.date )
{
RegisterFile( pi->fi.name, pi );
}
}
}
}
}
void CFileMng::WritePackFileLog( char* str, ... )
{
#ifdef _DEBUG_no
FILE *fp;
char buf[4096];
va_list marker;
memset( buf, 0, sizeof( buf ) );
va_start( marker, str );
vsprintf( buf, str, marker);
fp = fopen( "fileMng.log", "at" );
fprintf( fp, "%s\n", buf );
fclose( fp );
#endif
}
void CFileMng::GetBaseDirectoryFromRegistry()
{
strcpy( m_basePath , "./" );
}
int CFileMng::PrepareMonsterPackFiles(int packType)
{
char path[128];
HANDLE hFile;
WIN32_FIND_DATA fileData;
char PackageName[MAX_PATH];
GetBaseDirectoryFromRegistry();
strcpy(path, m_monsterPath);
memset(PackageName, 0, sizeof(PackageName));
strcpy(PackageName, m_monsterPath);
switch( packType )
{
case ZIP_VERSION_PACK:
{
strcat( path , "*.pack" );
}
break;
case I3D_VERSION_PACK:
{
strcat( path , "*.i3d" );
}
break;
}
hFile = FindFirstFile( path , &fileData );
if( hFile == INVALID_HANDLE_VALUE )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is no pack file" );
return false;
}
strcat(PackageName, fileData.cFileName);
::PackFileOpen( &m_packFiles[ m_numPackFiles++ ] , PackageName);
while( FindNextFile( hFile , &fileData ) )
{
memset(PackageName, 0, sizeof(PackageName));
strcpy(PackageName, m_monsterPath);
strcat(PackageName, fileData.cFileName);
::PackFileOpen( &m_packFiles[ m_numPackFiles++ ] , PackageName );
}
FindClose( hFile );
return true;
}
int CFileMng::PrepareNPCPackFiles(int packType)
{
char path[128];
HANDLE hFile;
WIN32_FIND_DATA fileData;
char PackageName[MAX_PATH];
GetBaseDirectoryFromRegistry();
strcpy(path, m_NPCPath);
memset(PackageName, 0, sizeof(PackageName));
strcpy(PackageName, m_NPCPath);
switch( packType )
{
case ZIP_VERSION_PACK:
{
strcat( path , "*.pack" );
}
break;
case I3D_VERSION_PACK:
{
strcat( path , "*.i3d" );
}
break;
}
hFile = FindFirstFile( path , &fileData );
if( hFile == INVALID_HANDLE_VALUE )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is no pack file" );
return false;
}
strcat(PackageName, fileData.cFileName);
::PackFileOpen( &m_packFiles[ m_numPackFiles++ ] , PackageName );
while( FindNextFile( hFile , &fileData ) )
{
memset(PackageName, 0, sizeof(PackageName));
strcpy(PackageName, m_NPCPath);
strcat(PackageName, fileData.cFileName);
::PackFileOpen( &m_packFiles[ m_numPackFiles++ ] , PackageName );
}
FindClose( hFile );
return true;
}
int CFileMng::PrepareItemPackFiles(int packType)
{
char path[128];
HANDLE hFile;
WIN32_FIND_DATA fileData;
char PackageName[MAX_PATH+1];
GetBaseDirectoryFromRegistry();
strcpy(path, m_itemPath);
memset(PackageName, 0, sizeof(PackageName));
strcpy(PackageName, m_itemPath);
switch( packType )
{
case ZIP_VERSION_PACK:
{
strcat( path , "*.pack" );
}
break;
case I3D_VERSION_PACK:
{
strcat( path , "*.i3d" );
}
break;
}
hFile = FindFirstFile( path , &fileData );
if( hFile == INVALID_HANDLE_VALUE )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is no pack file" );
return false;
}
strcat(PackageName, fileData.cFileName);
::PackFileOpen( &m_packFiles[ m_numPackFiles++ ] , fileData.cFileName );
while( FindNextFile( hFile , &fileData ) )
{
memset(PackageName, 0, sizeof(PackageName));
strcpy(PackageName, m_itemPath);
strcat(PackageName, fileData.cFileName);
::PackFileOpen( &m_packFiles[ m_numPackFiles++ ] , fileData.cFileName );
}
FindClose( hFile );
return true;
}
int CFileMng::PrepareEarthPackageFiles(int packType)
{
char path[128];
HANDLE hFile;
WIN32_FIND_DATA fileData;
char PackageName[MAX_PATH+1];
GetBaseDirectoryFromRegistry();
strcpy(path, m_earthPath);
memset(PackageName, 0, sizeof(PackageName));
strcpy(PackageName, m_itemPath);
switch( packType )
{
case ZIP_VERSION_PACK:
{
strcat( path , "*.pack" );
}
break;
case I3D_VERSION_PACK:
{
strcat( path , "*.i3d" );
}
break;
}
hFile = FindFirstFile( path , &fileData );
if( hFile == INVALID_HANDLE_VALUE )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is no pack file" );
return false;
}
strcat(PackageName, fileData.cFileName);
::PackFileOpen( &m_packFiles[ m_numPackFiles++ ] , fileData.cFileName );
while( FindNextFile( hFile , &fileData ) )
{
memset(PackageName, 0, sizeof(PackageName));
strcpy(PackageName, m_earthPath);
strcat(PackageName, fileData.cFileName);
::PackFileOpen( &m_packFiles[ m_numPackFiles++ ] , fileData.cFileName );
}
FindClose( hFile );
return true;
}
int CFileMng::PrepareOccultPackageFiles(int packType)
{
char path[128];
HANDLE hFile;
WIN32_FIND_DATA fileData;
char PackageName[MAX_PATH+1];
GetBaseDirectoryFromRegistry();
strcpy(path, m_occultPath);
memset(PackageName, 0, sizeof(PackageName));
strcpy(PackageName, m_itemPath);
switch( packType )
{
case ZIP_VERSION_PACK:
{
strcat( path , "*.pack" );
}
break;
case I3D_VERSION_PACK:
{
strcat( path , "*.i3d" );
}
break;
}
hFile = FindFirstFile( path , &fileData );
if( hFile == INVALID_HANDLE_VALUE )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is no pack file" );
return false;
}
strcat(PackageName, fileData.cFileName);
::PackFileOpen( &m_packFiles[ m_numPackFiles++ ] , fileData.cFileName );
while( FindNextFile( hFile , &fileData ) )
{
memset(PackageName, 0, sizeof(PackageName));
strcpy(PackageName, m_occultPath);
strcat(PackageName, fileData.cFileName);
::PackFileOpen( &m_packFiles[ m_numPackFiles++ ] , fileData.cFileName );
}
FindClose( hFile );
return true;
}
int CFileMng::PrepareWindPackageFiles(int packType)
{
char path[128];
HANDLE hFile;
WIN32_FIND_DATA fileData;
char PackageName[MAX_PATH+1];
GetBaseDirectoryFromRegistry();
strcpy(path, m_windPath);
memset(PackageName, 0, sizeof(PackageName));
strcpy(PackageName, m_itemPath);
switch( packType )
{
case ZIP_VERSION_PACK:
{
strcat( path , "*.pack" );
}
break;
case I3D_VERSION_PACK:
{
strcat( path , "*.i3d" );
}
break;
}
hFile = FindFirstFile( path , &fileData );
if( hFile == INVALID_HANDLE_VALUE )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is no pack file" );
return false;
}
strcat(PackageName, fileData.cFileName);
::PackFileOpen( &m_packFiles[ m_numPackFiles++ ] , fileData.cFileName );
while( FindNextFile( hFile , &fileData ) )
{
memset(PackageName, 0, sizeof(PackageName));
strcpy(PackageName, m_windPath);
strcat(PackageName, fileData.cFileName);
::PackFileOpen( &m_packFiles[ m_numPackFiles++ ] , fileData.cFileName );
}
FindClose( hFile );
return true;
}
int CFileMng::PrepareWaterPackageFiles(int packType)
{
char path[128];
HANDLE hFile;
WIN32_FIND_DATA fileData;
char PackageName[MAX_PATH+1];
GetBaseDirectoryFromRegistry();
strcpy(path, m_waterPath);
memset(PackageName, 0, sizeof(PackageName));
strcpy(PackageName, m_itemPath);
switch( packType )
{
case ZIP_VERSION_PACK:
{
strcat( path , "*.pack" );
}
break;
case I3D_VERSION_PACK:
{
strcat( path , "*.i3d" );
}
break;
}
hFile = FindFirstFile( path , &fileData );
if( hFile == INVALID_HANDLE_VALUE )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is no pack file" );
return false;
}
strcat(PackageName, fileData.cFileName);
::PackFileOpen( &m_packFiles[ m_numPackFiles++ ] , fileData.cFileName );
while( FindNextFile( hFile , &fileData ) )
{
memset(PackageName, 0, sizeof(PackageName));
strcpy(PackageName, m_waterPath);
strcat(PackageName, fileData.cFileName);
::PackFileOpen( &m_packFiles[ m_numPackFiles++ ] , fileData.cFileName );
}
FindClose( hFile );
return true;
}
int CFileMng::PreparePackFiles(int packType)
{
char path[128];
HANDLE hFile;
WIN32_FIND_DATA fileData;
GetBaseDirectoryFromRegistry();
strcpy( path , m_basePath );
strcat( path , m_dataPath );
SetCurrentDirectory( path );
m_numPackFiles = 0;
switch( packType )
{
case ZIP_VERSION_PACK:
{
strcpy( path , "*.pack" );
}
break;
case I3D_VERSION_PACK:
{
strcpy( path , "*.i3d" );
}
break;
}
hFile = FindFirstFile( path , &fileData );
if( hFile == INVALID_HANDLE_VALUE )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is no pack file" );
return false;
}
::PackFileOpen( &m_packFiles[ m_numPackFiles++ ] , fileData.cFileName );
while( FindNextFile( hFile , &fileData ) )
::PackFileOpen( &m_packFiles[ m_numPackFiles++ ] , fileData.cFileName );
PrepareMonsterPackFiles(packType);
PrepareNPCPackFiles(packType);
PrepareItemPackFiles(packType);
PrepareEarthPackageFiles(packType);
PrepareOccultPackageFiles(packType);
PrepareWindPackageFiles(packType);
PrepareWaterPackageFiles(packType);
FindClose( hFile );
MakePackFilesMap();
return true;
}
int CFileMng::ReadExtFilesFromPack( char *ext , packsearch_t **searchList )
{
int numFound;
char *extention;
*searchList = m_packSearch;
numFound = 0;
packfilemap::iterator i = m_fileMap.begin();
while( i != m_fileMap.end() )
{
packfileinfo_t *pi = (*i ++).second;
if( pi == NULL )
continue;
extention = GetFileExt( pi->fi.name );
if( !extention ) continue;
if( !stricmp( extention , ext ) )
{
m_packSearch[numFound].pack = pi->packidx;
m_packSearch[numFound].entry = pi->idx_inpack;
m_packSearch[numFound].size = pi->fi.size;
m_packSearch[numFound].date = pi->fi.date;
strcpy( m_packSearch[numFound].name , pi->fi.name );
numFound ++;
}
}
return numFound;
}
BYTE *CFileMng::ReadFileFromPack( packsearch_t *packSearch )
{
char *buf;
DWORD size;
size = PackFileGetFileWithIndex( &m_packFiles[ packSearch->pack ] , packSearch->entry , &buf );
string readedfname = packSearch->name;
if( find( readedfilemap.begin(), readedfilemap.end(), readedfname ) != readedfilemap.end() )
{
WritePackFileLog( "%s Read Duplicated!(%.2f)", packSearch->name, (float)packSearch->size * 0.001f );
dupReadedFilesize += packSearch->size;
WritePackFileLog( "TotalSize : %.2fk", (float)dupReadedFilesize * 0.001f );
}
else
{
readedfilemap.push_back( readedfname );
}
if( size <= 0 )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is an error in extracting file" );
WritePackFileLog( "%s There is an error in extracting file", packSearch->name );
return NULL;
}
return (BYTE*) buf;
}
DWORD CFileMng::GetFileDateFromPack( char *fname )
{
packfileinfo_t *pi = GetFromFilename( fname );
if( pi == NULL )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is no such file" );
WritePackFileLog( "%s There is no such file", fname );
return NULL;
}
return pi->fi.date;
}
DWORD CFileMng::GetFileSizeFromPack( char *fname )
{
packfileinfo_t *pi = GetFromFilename( fname );
DWORD size;
if( pi == NULL )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is no such file" );
WritePackFileLog( "%s There is no such file", fname );
return NULL;
}
size = pi->fi.size;
if( size <= 0 )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is an error in file" );
WritePackFileLog( "%s There is an error in file", fname );
return NULL;
}
return size;
}
BYTE *CFileMng::ReadFileFromPack( char *fname )
{
packfileinfo_t *pi = GetFromFilename( fname );
DWORD size;
char *buf;
if( pi == NULL )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is no such file" );
WritePackFileLog( "%s There is no such file", fname );
return NULL;
}
string readedfname = fname;
if( find( readedfilemap.begin(), readedfilemap.end(), readedfname ) != readedfilemap.end() )
{
WritePackFileLog( "%s Read Duplicated!(%.2fk)", fname, (float)pi->fi.size * 0.001f );
dupReadedFilesize += pi->fi.size;
WritePackFileLog( "TotalSize : %.2fk", (float)dupReadedFilesize * 0.001f );
}
else
{
readedfilemap.push_back( readedfname );
}
size = PackFileGetFileWithIndex( &m_packFiles[pi->packidx], pi->idx_inpack, &buf );
if( size <= 0 )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is an error in extracting file" );
WritePackFileLog( "%s There is an error in extracting file", fname );
return NULL;
}
return (BYTE*) buf;
}
DWORD CFileMng::GetFileSize( char *fname )
{
char path[128];
HANDLE hFile;
DWORD size;
strcpy( path , m_basePath );
strcat( path , m_dataPath );
SetCurrentDirectory( path );
strcat( path , fname );
hFile = CreateFile( path , GENERIC_READ , FILE_SHARE_READ , NULL
, OPEN_EXISTING , FILE_ATTRIBUTE_NORMAL , NULL );
if( hFile == INVALID_HANDLE_VALUE )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is no such file" );
return false;
}
size = ::GetFileSize( hFile , NULL );
CloseHandle( hFile );
return size;
}
BYTE *CFileMng::ReadFile( char *fname )
{
char path[128];
HANDLE hFile;
DWORD size , sizeRead;
int ret;
BYTE *buf;
strcpy( path , m_basePath );
strcat( path , m_dataPath );
SetCurrentDirectory( path );
strcat( path , fname );
hFile = CreateFile( path , GENERIC_READ , FILE_SHARE_READ , NULL
, OPEN_EXISTING , FILE_ATTRIBUTE_NORMAL , NULL );
if( hFile == INVALID_HANDLE_VALUE )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is no such file" );
return false;
}
size = ::GetFileSize( hFile , NULL );
buf = new BYTE[ size ];
ret = ::ReadFile( hFile , buf , size , &sizeRead , NULL );
if( !ret || ( sizeRead != size ) )
{
CloseHandle( hFile );
GTH_ERROR( GTH_ERROR_PRINT , "There is an error in reading file" );
return false;
}
CloseHandle( hFile );
return buf;
}
void CFileMng::SetBaseDirectory( char *path )
{
strcpy( m_basePath , path );
}
char *CFileMng::GetFileExt( char *fname )
{
int i , found;
int pathLen = strlen( fname );
found = 0;
for( i = 0 ; i < pathLen ; i++ )
{
if( fname[i] == '.' )
{
found = i;
break;
}
}
if( found ) return fname + found + 1;
else return NULL;
}
char *CFileMng::GetFileName( char *fname )
{
int i,found;
int pathLen = strlen( fname );
found = false;
for( i = pathLen - 1 ; i >= 0 ; i-- )
{
if( ( fname[i] == '/' ) || ( fname[i] == '\\' ) )
{
found = true;
break;
}
}
if( found ) return fname + i + 1;
else return fname;
}
char *CFileMng::GetFileNameOnly( char *fname )
{
int i,found;
int pathLen = strlen( fname );
found = false;
for( i = pathLen - 1 ; i >= 0 ; i-- )
{
if( ( fname[i] == '.' ) )
{
found = true;
break;
}
}
if( found ) fname[ i ] = 0;
return fname;
}
char *CFileMng::GetFilePath( char *fname )
{
int i,found;
int pathLen = strlen( fname );
found = false;
for( i = pathLen - 1 ; i >= 0 ; i-- )
{
if( ( fname[i] == '/' ) || ( fname[i] == '\\' ) )
{
found = true;
break;
}
}
if( found ) fname[ i + 1 ] = 0;
else fname[0] = 0;
return fname;
}
void CFileMng::ConvertUnixPath( char *path )
{
int pathLen = strlen(path);
for( int i = 0 ; i < pathLen ; i++ )
if( path[i] == '\\' )
path[i] = '/';
}
filetype_t CFileMng::FindFileType( char* fname )
{
char *extension;
extension = GetFileExt( fname );
if( !extension )
return NOT_SUPPORTED_FILE_TYPE;
if ( !strcmpi(extension, "zip") ) return DOWN_ZIP_FILE_TYPE;
else if ( !strcmpi(extension, "i3d") ) return DOWN_ZIP_FILE_TYPE;
else if ( !strcmpi(extension, "pak") ) return DOWN_ZIP_FILE_TYPE;
else if ( !strcmpi(extension, "md3") ) return MODEL_MD3_FILE_TYPE;
else if ( !strcmpi(extension, "bsp") ) return WORLD_BSP_FILE_TYPE;
else if ( !strcmpi(extension, "sector") ) return WORLD_SECTOR_FILE_TYPE;
else if ( !strcmpi(extension, "jpg") ) return TEXTURE_JPEG_FILE_TYPE;
else if ( !strcmpi(extension, "jpeg") ) return TEXTURE_JPEG_FILE_TYPE;
else if ( !strcmpi(extension, "tga") ) return TEXTURE_TGA_FILE_TYPE;
else if ( !strcmpi(extension, "bmp") ) return TEXTURE_BMP_FILE_TYPE;
else if ( !strcmpi(extension, "shader") ) return SCRIPT_SHADER_FILE_TYPE;
else if ( !strcmpi(extension, "object") ) return SCRIPT_OBJECT_FILE_TYPE;
else if ( !strcmpi(extension, "class") ) return SCRIPT_CLASS_FILE_TYPE;
else if ( !strcmpi(extension, "cfg") ) return SCRIPT_AVATAR_FILE_TYPE;
else if ( !strcmpi(extension, "wav") ) return SOUND_WAVE_FILE_TYPE;
else if ( !strcmpi(extension, "mp3") ) return SOUND_MPEG_FILE_TYPE;
else if ( !strcmpi(extension, "raw") ) return SOUND_RAW_FILE_TYPE;
else if ( !strcmpi(extension, "dat") ) return CHARACTER_CONFIG_FILE_TYPE;
else if ( !strcmpi(extension, "csf") ) return CHARACTER_SKELETON_FILE_TYPE;
else if ( !strcmpi(extension, "caf") ) return CHARACTER_ANIMATION_FILE_TYPE;
else if ( !strcmpi(extension, "cmf") ) return CHARACTER_MESH_FILE_TYPE;
else
return NOT_SUPPORTED_FILE_TYPE;
}
bool CFileMng::RegisterFileFromPack( char* fname, RHANDLE rhID, BaseResource *pRes, DWORD initialType )
{
packfileinfo_t *pi = GetFromFilename( fname );
DWORD size;
if( pi == NULL )
{
GTH_ERROR( GTH_ERROR_PRINT , "There is no such file" );
WritePackFileLog( "%s There is no such file", fname );
return false;
}
size = pi->fi.size;
if( initialType & RES_INIT_NOTCREATE )
{
if( !m_resMng->RegisterResource( rhID, pRes ) ) return false;
if( !pRes->Register( fname, size ) ) return false;
}
else
{
if( !m_resMng->ReserveMemory( size ) ) return false;
if( !pRes->Create( fname, size ) ) return false;
if( !m_resMng->InsertResource( rhID, pRes ) ) return false;
}
return true;
}
| C++ |
#if !defined(AFX_FILEMNG_H__DB30E545_3A8E_44CD_AF4D_700AF6FFBAF1__INCLUDED_)
#define AFX_FILEMNG_H__DB30E545_3A8E_44CD_AF4D_700AF6FFBAF1__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#pragma warning (disable:4786)
#include <IOSTREAM>
#include <algorithm>
#include <STRING>
#include <MAP>
#include "../zlib/unpak.h"
#include "ResManager.h"
using namespace std;
typedef enum
{
NOT_SUPPORTED_FILE_TYPE,
DOWN_ZIP_FILE_TYPE,
MODEL_AVATA_FILE_TYPE,
MODEL_MD3_FILE_TYPE,
MODEL_MD2_FILE_TYPE,
MODEL_3DS_FILE_TYPE,
WORLD_BSP_FILE_TYPE,
WORLD_SECTOR_FILE_TYPE,
WORLD_ZONE_FILE_TYPE,
TEXTURE_JPEG_FILE_TYPE,
TEXTURE_TGA_FILE_TYPE,
TEXTURE_GIF_FILE_TYPE,
TEXTURE_BMP_FILE_TYPE,
SCRIPT_SHADER_FILE_TYPE,
SCRIPT_OBJECT_FILE_TYPE,
SCRIPT_MD3SHADER_FILE_TYPE,
SCRIPT_CLASS_FILE_TYPE,
SCRIPT_AVATAR_FILE_TYPE,
SCRIPT_SKIN_FILE_TYPE,
SOUND_WAVE_FILE_TYPE,
SOUND_MPEG_FILE_TYPE,
SOUND_RAW_FILE_TYPE,
CHARACTER_CONFIG_FILE_TYPE,
CHARACTER_SKELETON_FILE_TYPE,
CHARACTER_ANIMATION_FILE_TYPE,
CHARACTER_MESH_FILE_TYPE
} filetype_t;
#define MAX_SIZE_PACK_FILE 512
#define MAX_SIZE_PACK_SEARCH 1024
typedef struct
{
fileinfo_t fi;
char pack_name[PACK_FILE_NAME_SIZE];
int idx_inpack;
int packidx;
} packfileinfo_t;
typedef map<string, packfileinfo_t*, less<string> > packfilemap;
class CFileMng
{
public :
CFileMng();
~CFileMng();
void ClosePackFiles();
int PreparePackFiles( int packType );
int PrepareMonsterPackFiles(int packType);
int PrepareNPCPackFiles(int packType);
int PrepareItemPackFiles(int packType);
int PrepareOccultPackageFiles(int packType);
int PrepareEarthPackageFiles(int packType);
int PrepareWaterPackageFiles(int packType);
int PrepareWindPackageFiles(int packType);
void GetBaseDirectoryFromRegistry();
int ReadExtFilesFromPack( char *ext , packsearch_t **list );
BYTE* ReadFileFromPack( packsearch_t *packSearch );
DWORD GetFileSizeFromPack( char *fname );
DWORD GetFileDateFromPack( char *fname );
BYTE* ReadFileFromPack( char *fname );
DWORD GetFileSize( char *fname );
BYTE* ReadFile( char *fname );
void SetBaseDirectory( char *path );
static char* GetFileExt( char *fname );
static char* GetFileName( char *fname );
static char* GetFilePath( char *fname );
static void ConvertUnixPath( char *path );
static filetype_t FindFileType( char* fname );
static char* GetFileNameOnly( char *fname );
int GetFilesCountInPack() { return( m_numFilesInPack ); }
void RegisterFile( char* fname, packfileinfo_t* fi );
packfileinfo_t* FindSameFilename( char *fname );
packfileinfo_t* GetFromFilename( char *fname );
packfileinfo_t* MakeFilesInfo( packfile_t *pf, int packidx, int idx );
void MakePackFilesMap();
void WritePackFileLog( char* str, ... );
void SetResourceManager( CResManager *resMng ) { m_resMng = resMng; }
bool RegisterFileFromPack( char* fname, RHANDLE rhID, BaseResource *pRes, DWORD initialType = 0 );
private :
packfilemap m_fileMap;
char m_basePath[128];
char m_dataPath[128];
char m_monsterPath[128];
char m_NPCPath[128];
char m_itemPath[128];
char m_earthPath[128];
char m_occultPath[128];
char m_waterPath[128];
char m_windPath[128];
int m_numPackFiles;
int m_numFilesInPack;
packfile_t m_packFiles[MAX_SIZE_PACK_FILE];
packsearch_t m_packSearch[MAX_SIZE_PACK_SEARCH];
CResManager* m_resMng;
};
inline void CFileMng::RegisterFile( char* fname, packfileinfo_t* fi )
{
packfileinfo_t *pi = new packfileinfo_t;
string fileType = fname;
memcpy( pi, fi, sizeof( packfileinfo_t ) );
m_fileMap[fileType] = pi;
}
inline packfileinfo_t* CFileMng::MakeFilesInfo( packfile_t *pf, int packidx, int idx )
{
static packfileinfo_t pi;
memcpy( &pi.fi, &pf->fi[idx], sizeof( fileinfo_t ) );
strcpy( pi.pack_name, pf->pak_name );
pi.packidx = packidx;
pi.idx_inpack = idx;
return( &pi );
}
inline packfileinfo_t* CFileMng::FindSameFilename( char *fname )
{
if( m_fileMap.find( fname ) == m_fileMap.end() )
{
return NULL;
}
return m_fileMap[fname];
}
inline packfileinfo_t* CFileMng::GetFromFilename( char *fname )
{
string fileType;
char lwFname[PACK_FILE_NAME_SIZE];
strcpy( lwFname, fname );
_strlwr( lwFname );
fileType = lwFname;
return m_fileMap[fileType];
}
extern CFileMng g_fileMng;
#endif
| C++ |
#if !defined(AFX_MDL_H__DAB6496D_0AF2_4D88_B853_78A981B4994F__INCLUDED_)
#define AFX_MDL_H__DAB6496D_0AF2_4D88_B853_78A981B4994F__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
enum
{
GTH_MODEL_BONEFRAME = 0 ,
GTH_MODEL_TAG ,
GTH_MODEL_MESH ,
GTH_MODEL_SHADERREFS ,
GTH_MODEL_VERTICES ,
GTH_MODEL_ELEMENTS ,
GTH_MODEL_BOUND_VERTICES ,
GTH_MODEL_BOUND_ELEMENTS ,
GTH_MODEL_BOUND_PLANES ,
GTH_MODEL_BOUND_MESH ,
GTH_MODEL_NUM_LUMPS
};
typedef struct
{
unsigned int offset, size;
} mdllump_t;
typedef struct
{
char id[4];
float version;
char name[ 64 ];
vec3_t mins;
vec3_t maxs;
mdllump_t lumps[ GTH_MODEL_NUM_LUMPS ];
char dummy[12];
int hasbou12ndmesh;
} mdlhead_t;
typedef struct
{
vec3_t mins;
vec3_t maxs;
vec3_t position;
float scale;
} mdlboneframe_t;
typedef struct
{
char name[64];
vec3_t origin;
vec3_t axis[3];
} mdltag3x3_t;
typedef struct
{
vec3_t point;
vec3_t normal;
vec2_t texUV;
} mdlvertex_t;
typedef int element_t;
typedef struct
{
char name[ 68 ];
int shader;
int surfaceFlags;
int isShader;
} mdlshaderref_t;
typedef struct
{
char name[ 52 ] ;
int needTCGen;
int offsetTCGenVB;
int offsetTCGenEB;
int numVertices;
int vertexOffset;
int vertexSize;
int numElems;
int elemOffset;
int elemSize;
int skinInfo;
int numMeshFrames;
int offsetVB;
int sizeVB;
int offsetEB;
int sizeEB;
} mdlmesh_t;
typedef struct
{
int numVertices;
int numElems;
} mdlboundmesh_t;
typedef struct
{
vec3_t point;
vec3_t normal;
} mdlboundvertex_t;
typedef struct
{
vec3_t normal;
float dist;
} mdlboundplane_t;
class CMDLMng;
class CMDL : public BaseResource
{
public:
int m_numBoneFrames;
int m_numTags;
int m_numMeshes;
int m_numShaderRefs;
int m_numVertices;
int m_numElems;
int m_numBoundVertices;
int m_numBoundElems;
int m_numBoundPlanes;
int m_numBoundMeshes;
int m_numFrameVertices;
int m_numFrameElems;
mdlboneframe_t *m_boneFrames;
mdltag3x3_t *m_tags;
mdlmesh_t *m_meshes;
mdlshaderref_t *m_shaderRefs;
mdlvertex_t *m_vertices;
element_t *m_elems;
mdlboundvertex_t *m_boundVertices;
element_t *m_boundElems;
mdlboundplane_t *m_boundPlanes;
mdlboundmesh_t *m_boundMeshes;
vec3_t m_mins;
vec3_t m_maxs;
char m_name[ GTH_MAX_SIZE_FILENAME ];
int m_soundIdx;
CFileMng *m_fileMng;
BYTE *m_buffer;
int m_iBufferSize;
mdlmesh_t *m_storedMeshes;
int m_iStoredMeshesSize;
int m_bank;
int m_baseVB;
int m_baseEB;
int m_sizeVB;
int m_sizeEB;
int m_needDynVB;
CMDL();
virtual ~CMDL();
void SetFileMng( CFileMng *fileMng ) { m_fileMng = fileMng; }
int Load( char *fname );
int GetShaderRef( mdlshaderref_t **shaderRef );
void Release();
void GenNormals();
void Clear()
{
m_buffer = NULL;
}
bool Create( char *fname, int iSize );
virtual bool Recreate();
virtual void Dispose()
{
GTH_SAFE_FREE( m_buffer );
}
size_t GetSize()
{
if( m_buffer ) return m_iBufferSize;
else return 0;
}
bool IsDisposed()
{
if( m_buffer ) return false;
else return true;
}
CMDLMng *m_mdlMng;
void SetMDLManager( CMDLMng *mdlMng ) { m_mdlMng = mdlMng; }
};
#endif
| C++ |
#include "../global_def.h"
int CMDLMng::LoadWorldClass( char *fname )
{
char *token;
mdlworldclass_t *mdlWorldClass;
mdlworldclasspart_t *part;
if( !m_script->Load( fname ) )
return false;
m_script->BeginParse();
while( 1 )
{
token = m_script->GetNextToken( true );
if( !token[0] ) break;
if( token[0] != '{' ) continue;
if( m_numMDLWorldClasses >= MAX_SIZE_MDL_WORLD_CLASS )
{
GTH_ERROR( GTH_ERROR_PRINT , "MDL World Class overflow.." );
break;
}
mdlWorldClass = &m_MDLWorldClasses[ m_numMDLWorldClasses++ ];
mdlWorldClass->numParts = 0;
memset( mdlWorldClass , 0 , sizeof( mdlworldclass_t ) );
while( 1 )
{
token = m_script->GetNextToken( true );
if( !token[0] ) break;
if (token[0] == '{')
{
part = &mdlWorldClass->parts[ mdlWorldClass->numParts++ ];
ParseWorldClassPart( part );
}
else if (token[0] == '}')
break;
else
ParseWorldClassToken( mdlWorldClass , token );
}
}
return true;
}
void CMDLMng::ParseWorldClassPart( mdlworldclasspart_t *part )
{
char *token , *param;
part->mdlIdx = -1;
part->msecPerFrame = 100.0f;
part->scale = 1.0f;
part->rotSpeed = 0.0f;
while( 1 )
{
token = m_script->GetNextToken( true );
if( !token[0] ) break;
if( token[0] == '}' )
{
break;
}
else if( !stricmp( token , "model" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
strcpy( part->mdlName , param );
}
else if( !stricmp( token , "scale" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->scale = (float) atof( param );
}
else if( !stricmp( token , "rotate_speed" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->rotSpeed = (float) atof( param );
}
else if( !stricmp( token , "tag" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
strcpy( part->tagName , param );
}
else if( !stricmp( token , "frame_per_second" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->msecPerFrame = (float) atof( param );
if( part->msecPerFrame > 1.0f )
part->msecPerFrame = 1000.0f / part->msecPerFrame;
}
m_script->SkipLine();
}
}
void CMDLMng::ParseWorldClassToken( mdlworldclass_t *mdlWorldClass , char *token )
{
char *param;
if( !stricmp( token , "classname" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
mdlWorldClass->classType = GetWorldClassType( param );
}
else if( !stricmp( token , "height" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
mdlWorldClass->bobHeight = (float) atof( param );
}
else if( !stricmp( token , "speed" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
mdlWorldClass->bobSpeed = (float) atof( param );
}
else if( !stricmp( token , "itemname" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
strcpy( mdlWorldClass->itemName , param );
}
else if( !stricmp( token , "hideFlag" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
mdlWorldClass->hideFlag = atoi( param );
}
m_script->SkipLine();
}
int CMDLMng::GetWorldClassType( char *token )
{
if ( !stricmp( token , "i3d_item_model" ) )
return GTH_WORLD_ENTITY_TYPE_MODEL;
else if( !stricmp( token , "i3d_info_player_start" ) )
return GTH_WORLD_ENTITY_TYPE_PLAYER_POS;
else if( !stricmp( token , "i3d_info_teleport" ) )
return GTH_WORLD_ENTITY_TYPE_TELEPORT;
else if( !stricmp( token , "i3d_info_activator" ) )
return GTH_WORLD_ENTITY_TYPE_ACTIVATOR;
else if( !stricmp( token , "i3d_info_deactivator" ) )
return GTH_WORLD_ENTITY_TYPE_DEACTIVATOR;
else if( !stricmp( token , "i3d_info_door" ) )
return GTH_WORLD_ENTITY_TYPE_DOOR;
else if( !stricmp( token , "i3d_info_path" ) )
return GTH_WORLD_ENTITY_TYPE_PATH;
else if( !stricmp( token , "i3d_info_camera_path" ) )
return GTH_WORLD_ENTITY_TYPE_CAMERA_PATH;
else if( !stricmp( token , "i3d_info_sound" ) )
return GTH_WORLD_ENTITY_TYPE_SOUND;
return GTH_WORLD_ENTITY_TYPE_NONE;
}
int CMDLMng::LinkMDLWorldClass( int idxMDLClass )
{
int i;
mdlworldclass_t *mdlWorldClass;
mdlworldclasspart_t *part;
int flag;
mdlWorldClass = &m_MDLWorldClasses[idxMDLClass];
if( mdlWorldClass->loaded ) return true;
flag = true;
part = &mdlWorldClass->parts[0];
for( i = 0 ; i < mdlWorldClass->numParts ; i++ , part++ )
{
if( part->tagName[0] )
{
if( !stricmp( part->tagName , "tag_hand" ) )
part->onlyTag = true;
}
part->mdlIdx = LoadMDL( part->mdlName );
if( part->mdlIdx < 0 )
{
flag = false;
break;
}
}
if( flag )
CalcWorldBoundBox( mdlWorldClass );
mdlWorldClass->loaded = flag;
return flag;
}
void CMDLMng::CalcWorldBoundBox( mdlworldclass_t *mdlWorldClass )
{
mdlworldclasspart_t *part;
vec3_t classMins , classMaxs;
vec3_t partMins , partMaxs;
CMDL *mdl;
int i;
ClearBounds( classMins , classMaxs );
part = &mdlWorldClass->parts[0];
for( i = 0 ; i < mdlWorldClass->numParts ; i++ , part++ )
{
mdl = GetMDL( part->mdlIdx );
if( mdl == NULL ) continue;
VectorCopy( partMins , mdl->m_mins );
VectorCopy( partMaxs , mdl->m_maxs );
if( part->rotSpeed != 0.0f )
{
CalcSphereBoundBox( partMins , partMaxs );
}
VectorScale( partMins , partMins , part->scale );
VectorScale( partMaxs , partMaxs , part->scale );
AddPointToBounds( partMins , classMins , classMaxs );
AddPointToBounds( partMaxs , classMins , classMaxs );
}
if( mdlWorldClass->bobSpeed != 0.0f )
{
classMins[2] -= mdlWorldClass->bobHeight;
classMaxs[2] += mdlWorldClass->bobHeight;
}
VectorCopy( mdlWorldClass->mins , classMins );
VectorCopy( mdlWorldClass->maxs , classMaxs );
}
void CMDLMng::SetMDLWorldEntityOrigin( int idxMDLEntity , vec3_t origin )
{
VectorCopy( m_MDLWorldEntities[ idxMDLEntity ].origin , origin );
}
void CMDLMng::SetMDLWorldEntityAngles( int idxMDLEntity , vec3_t angles )
{
m_MDLWorldEntities[ idxMDLEntity ].rotate = angles[YAW];
}
mdlworldentity_t *CMDLMng::GetMDLWorldEntity( int idxMDLEntity )
{
return &m_MDLWorldEntities[ idxMDLEntity ];
}
mdlworldentitylink_t *CMDLMng::GetLinkedMDLWorldEntity( int idxClass )
{
return &m_linkedMDLWorldEntities[ idxClass ];
}
void CMDLMng::ClearWorldUseFlag()
{
ClearRenderWorldLink();
ClearBlendWorldLink();
memset( m_linkedMDLWorldEntities , 0 , sizeof( mdlworldentitylink_t ) * m_numMDLWorldClasses );
memset( m_worldInUse , 0 , sizeof( int ) * MAX_SIZE_MDL_WORLD_ENTITY );
m_currMDLWorldEntity = 0;
}
int CMDLMng::AddWorldEntity( char *itemName , vec3_t origin , vec3_t angles )
{
mdlworldclass_t *mdlWorldClass;
mdlworldentity_t *mdlEntity;
mdlworldentitylink_t *linkedMDLEntity;
int i;
int idxClass , found;
mdlWorldClass = &m_MDLWorldClasses[0];
for( i = 0 ; i < m_numMDLWorldClasses ; i++ , mdlWorldClass++ )
{
if( mdlWorldClass->classType != GTH_WORLD_ENTITY_TYPE_MODEL
&& mdlWorldClass->classType != GTH_WORLD_ENTITY_TYPE_TELEPORT ) continue;
if( !stricmp( mdlWorldClass->itemName , itemName ) )
{
idxClass = i;
break;
}
}
if( i == m_numMDLWorldClasses ) return -1;
if( !LinkMDLWorldClass( i ) ) return -1;
found = -1;
for( i = m_currMDLWorldEntity ; i < MAX_SIZE_MDL_WORLD_ENTITY ; i++ )
{
if( !m_worldInUse[i] )
{
found = i;
goto NEXT_FREE_MDL_WORLD_ENTITY;
}
}
for( i = 0 ; i < m_currMDLWorldEntity ; i++ )
{
if( !m_worldInUse[i] )
{
found = i;
goto NEXT_FREE_MDL_WORLD_ENTITY;
}
}
if( found == -1 )
{
found = m_currMDLWorldEntity + 1;
if( found >= MAX_SIZE_MDL_WORLD_ENTITY )
found = 0;
DeleteWorldEntity( found );
}
NEXT_FREE_MDL_WORLD_ENTITY :
m_currMDLWorldEntity = found;
mdlEntity = &m_MDLWorldEntities[ m_currMDLWorldEntity ];
linkedMDLEntity = &m_linkedMDLWorldEntities[ idxClass ];
mdlEntity->idxClass = idxClass;
mdlEntity->next = linkedMDLEntity->linked;
mdlEntity->prev = NULL;
if( linkedMDLEntity->linked )
linkedMDLEntity->linked->prev = mdlEntity;
linkedMDLEntity->linked = mdlEntity;
VectorCopy( mdlEntity->origin , origin );
mdlEntity->rotate = angles[ YAW ];
mdlEntity->visible = false;
m_worldInUse[ m_currMDLWorldEntity ] = true;
MakeTransformedMDL( mdlEntity, idxClass );
return m_currMDLWorldEntity;
}
void CMDLMng::MakeTransformedMDL( mdlworldentity_t *entity, int idxClass )
{
mdlworldclass_t *worldClass;
mdlworldclasspart_t *part;
CMDL *mdl;
int i, j;
float cosval, sinval;
float radval;
mdlboundvertex_t *source;
worldClass = &m_MDLWorldClasses[idxClass];
part = &worldClass->parts[0];
for( i = 0 ; i < worldClass->numParts ; i++ , part++ )
{
mdl = GetMDL( part->mdlIdx );
if( mdl == NULL ) continue;
entity->num_cvertex[i] = mdl->m_numBoundVertices;
if ( mdl->m_numBoundVertices > 0 )
entity->collisionVertex[i] = new vec3_t [mdl->m_numBoundVertices];
else
entity->collisionVertex[i] = NULL;
radval = deg2rad( entity->rotate );
cosval = cos( radval );
sinval = sin( radval );
source = &mdl->m_boundVertices[0];
for ( j = 0; j < mdl->m_numBoundVertices; j++, source++ )
{
entity->collisionVertex[i][j][0] = cosval*source->point[0] - sinval*source->point[1] + entity->origin[0];
entity->collisionVertex[i][j][1] = sinval*source->point[0] + cosval*source->point[1] + entity->origin[1];
entity->collisionVertex[i][j][2] = source->point[2] + entity->origin[2];
}
}
}
int CMDLMng::DeleteWorldEntity( int idxMDLEntity )
{
mdlworldentity_t *mdlEntity;
mdlEntity = &m_MDLWorldEntities[ idxMDLEntity ];
if( !m_worldInUse[ idxMDLEntity ] ) return true;
if( mdlEntity->prev )
{
mdlEntity->prev->next = mdlEntity->next;
}
else
{
m_linkedMDLWorldEntities[ mdlEntity->idxClass ].linked = mdlEntity->next;
}
if( mdlEntity->next )
mdlEntity->next->prev = mdlEntity->prev;
mdlEntity->next = NULL;
mdlEntity->prev = NULL;
m_worldInUse[ idxMDLEntity ] = false;
return true;
}
int CMDLMng::GetMDLWorldClassBoundBox( int idxMDLEntity , vec3_t mins , vec3_t maxs )
{
mdlworldentity_t *mdlEntity;
mdlEntity = &m_MDLWorldEntities[ idxMDLEntity ];
if( !m_worldInUse[ idxMDLEntity ] ) return false;
VectorCopy( mins , m_MDLWorldClasses[ mdlEntity->idxClass ].mins );
VectorCopy( maxs , m_MDLWorldClasses[ mdlEntity->idxClass ].maxs );
if( mdlEntity->rotate != 0.0f )
CalcZAxisRotateBoundBox( mdlEntity->rotate , mins , maxs );
return true;
}
void CMDLMng::RenderWorldEntity()
{
int i , j , k;
mdlworldentity_t **linked;
mdlworldclass_t *mdlWorldClass;
mdlworldclasspart_t *mdlWorldClassPart;
mdlworldentity_t *mdlWorldEntity;
CMDL *mdl;
mdlmesh_t *mesh;
float bob;
vec3_t scale , position;
matrix4x4_t tmp;
shader_t *shader;
linked = &m_linkedRenderMDLWorldEntities[0];
mdlWorldClass = &m_MDLWorldClasses[0];
for( i = 0 ; i < m_numMDLWorldClasses ; i++ , linked++ , mdlWorldClass++ )
{
if( !*linked ) continue;
m_waveFunc.amplitude = mdlWorldClass->bobHeight;
m_waveFunc.frequency = mdlWorldClass->bobSpeed;
bob = m_shaderMng->EvaluateFunc( &m_waveFunc , m_currTime );
mdlWorldClassPart = &mdlWorldClass->parts[0];
for( j = 0 ; j < mdlWorldClass->numParts ; j++ , mdlWorldClassPart++ )
{
if( mdlWorldClassPart->onlyTag ) continue;
mdl = GetMDL( mdlWorldClassPart->mdlIdx );
if( mdl == NULL ) continue;
VectorSet( scale , mdlWorldClassPart->scale , mdlWorldClassPart->scale , mdlWorldClassPart->scale );
if( mdl->m_numBoneFrames > 1 )
{
m_isInterpolated = true;
m_interPol = m_currMilliTime / mdlWorldClassPart->msecPerFrame;
m_currFrame = ( (int) m_interPol ) % ( mdl->m_numBoneFrames - 1 );
m_interPol = m_interPol - ( (int) m_interPol );
}
else
{
m_isInterpolated = false;
m_interPol = 0.0f;
m_currFrame = 0;
}
if( m_isInterpolated )
{
for( k = 0 ; k < mdl->m_numMeshes ; k++ )
PrepareInterpolateMDL( mdl , &mdl->m_meshes[k] );
m_D3DRender->SetStreamSource( 0 , m_dynamicVB->GetD3DVertexBuffer() , m_dynamicVB->GetStrideSize() );
m_D3DRender->SetIndices( m_dynamicIB->GetD3DIndexBuffer() , 0 );
m_currBank = -1;
}
else
{
if( mdl->m_needDynVB )
{
for( k = 0 ; k < mdl->m_numMeshes ; k++ )
PrepareMDL( mdl , &mdl->m_meshes[k] );
m_D3DRender->SetStreamSource( 0 , m_dynamicVB->GetD3DVertexBuffer() , m_dynamicVB->GetStrideSize() );
m_D3DRender->SetIndices( m_dynamicIB->GetD3DIndexBuffer() , 0 );
m_currBank = -1;
}
else
{
if( m_currBank != mdl->m_bank )
{
m_D3DRender->SetStreamSource( 0 , m_staticVB[ mdl->m_bank ]->GetD3DVertexBuffer()
, m_staticVB[ mdl->m_bank ]->GetStrideSize() );
m_currBank = mdl->m_bank;
}
m_D3DRender->SetIndices( m_staticEB->GetD3DIndexBuffer() , 0 );
}
}
mesh = &mdl->m_meshes[0];
for( k = 0 ; k < mdl->m_numMeshes ; k++ , mesh++ )
{
if( mdl->m_shaderRefs[ mesh->skinInfo ].isShader )
m_shaderMng->PrepareShader( mdl->m_shaderRefs[ mesh->skinInfo ].shader , m_frameFlag );
}
mdlWorldEntity = *linked;
while( mdlWorldEntity )
{
if( !mdlWorldEntity->visible )
{
mdlWorldEntity = mdlWorldEntity->renderNext;
continue;
}
m_transform.Identity();
VectorSet( position , mdlWorldEntity->origin[0] , mdlWorldEntity->origin[1] , mdlWorldEntity->origin[2] + bob );
m_transform.Translate( position );
if( mdlWorldClassPart->rotSpeed == 0.0f )
m_transform.RotateZ( mdlWorldEntity->rotate );
else
m_transform.RotateZ( mdlWorldClassPart->rotSpeed * m_currTime * 180.0f );
tmp.Scale( scale );
m_transform *= tmp;
m_D3DRender->SetTransform( D3DTS_WORLD , &m_transform );
mesh = &mdl->m_meshes[0];
for( k = 0 ; k < mdl->m_numMeshes ; k++ , mesh++ )
{
if( mdl->m_shaderRefs[ mesh->skinInfo ].isShader )
{
shader = &m_shaderMng->m_shaders[ mdl->m_shaderRefs[ mesh->skinInfo ].shader ];
if( shader->flags & SHADER_TCGEN )
m_shaderMng->PrepareTCGen( shader , position );
m_D3DRender->RenderMDLCustom( shader , mesh->offsetVB , mesh->numVertices , mesh->offsetEB , mesh->numElems );
}
else
{
m_D3DRender->SetTexture( 0 , m_texMng->GetD3DTexture( mdl->m_shaderRefs[ mesh->skinInfo ].shader ) );
m_D3DRender->RenderDefault( mesh->offsetVB , mesh->numVertices , mesh->offsetEB , mesh->numElems );
}
m_totalRenderPolygon += mdl->m_meshes[k].numElems / 3;
}
mdlWorldEntity = mdlWorldEntity->renderNext;
}
}
}
}
void CMDLMng::RenderBlendWorldEntity()
{
int i , j , k;
mdlworldentity_t **linked;
mdlworldclass_t *mdlWorldClass;
mdlworldclasspart_t *mdlWorldClassPart;
mdlworldentity_t *mdlWorldEntity;
CMDL *mdl;
mdlmesh_t *mesh;
float bob;
vec3_t scale , position;
matrix4x4_t tmp;
shader_t *shader;
m_pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
m_pD3DDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
linked = &m_linkedBlendMDLWorldEntities[0];
mdlWorldClass = &m_MDLWorldClasses[0];
for( i = 0 ; i < m_numMDLWorldClasses ; i++ , linked++ , mdlWorldClass++ )
{
if( !*linked ) continue;
m_waveFunc.amplitude = mdlWorldClass->bobHeight;
m_waveFunc.frequency = mdlWorldClass->bobSpeed;
bob = m_shaderMng->EvaluateFunc( &m_waveFunc , m_currTime );
mdlWorldClassPart = &mdlWorldClass->parts[0];
for( j = 0 ; j < mdlWorldClass->numParts ; j++ , mdlWorldClassPart++ )
{
if( mdlWorldClassPart->onlyTag ) continue;
mdl = GetMDL( mdlWorldClassPart->mdlIdx );
if( mdl == NULL ) continue;
VectorSet( scale , mdlWorldClassPart->scale , mdlWorldClassPart->scale , mdlWorldClassPart->scale );
if( mdl->m_numBoneFrames > 1 )
{
m_isInterpolated = true;
m_interPol = m_currMilliTime / mdlWorldClassPart->msecPerFrame;
m_currFrame = ( (int) m_interPol ) % ( mdl->m_numBoneFrames - 1 );
m_interPol = m_interPol - ( (int) m_interPol );
}
else
{
m_isInterpolated = false;
m_interPol = 0.0f;
m_currFrame = 0;
}
if( m_isInterpolated )
{
for( k = 0 ; k < mdl->m_numMeshes ; k++ )
PrepareInterpolateMDL( mdl , &mdl->m_meshes[k] );
m_D3DRender->SetStreamSource( 0 , m_dynamicVB->GetD3DVertexBuffer() , m_dynamicVB->GetStrideSize() );
m_D3DRender->SetIndices( m_dynamicIB->GetD3DIndexBuffer() , 0 );
m_currBank = -1;
}
else
{
if( mdl->m_needDynVB )
{
for( k = 0 ; k < mdl->m_numMeshes ; k++ )
PrepareMDL( mdl , &mdl->m_meshes[k] );
m_D3DRender->SetStreamSource( 0 , m_dynamicVB->GetD3DVertexBuffer() , m_dynamicVB->GetStrideSize() );
m_D3DRender->SetIndices( m_dynamicIB->GetD3DIndexBuffer() , 0 );
m_currBank = -1;
}
else
{
if( m_currBank != mdl->m_bank )
{
m_D3DRender->SetStreamSource( 0 , m_staticVB[ mdl->m_bank ]->GetD3DVertexBuffer()
, m_staticVB[ mdl->m_bank ]->GetStrideSize() );
m_currBank = mdl->m_bank;
}
m_D3DRender->SetIndices( m_staticEB->GetD3DIndexBuffer() , 0 );
}
}
mesh = &mdl->m_meshes[0];
for( k = 0 ; k < mdl->m_numMeshes ; k++ , mesh++ )
{
if( mdl->m_shaderRefs[ mesh->skinInfo ].isShader )
m_shaderMng->PrepareShader( mdl->m_shaderRefs[ mesh->skinInfo ].shader , m_frameFlag );
}
mdlWorldEntity = *linked;
while( mdlWorldEntity )
{
if( !mdlWorldEntity->visible )
{
mdlWorldEntity = mdlWorldEntity->blendNext;
continue;
}
m_transform.Identity();
VectorSet( position , mdlWorldEntity->origin[0] , mdlWorldEntity->origin[1] , mdlWorldEntity->origin[2] + bob );
m_transform.Translate( position );
if( mdlWorldClassPart->rotSpeed == 0.0f )
m_transform.RotateZ( mdlWorldEntity->rotate );
else
m_transform.RotateZ( mdlWorldClassPart->rotSpeed * m_currTime * 180.0f );
tmp.Scale( scale );
m_transform *= tmp;
m_D3DRender->SetTransform( D3DTS_WORLD , &m_transform );
mesh = &mdl->m_meshes[0];
for( k = 0 ; k < mdl->m_numMeshes ; k++ , mesh++ )
{
if( mdl->m_shaderRefs[ mesh->skinInfo ].isShader )
{
shader = &m_shaderMng->m_shaders[ mdl->m_shaderRefs[ mesh->skinInfo ].shader ];
if( shader->flags & SHADER_TCGEN )
m_shaderMng->PrepareTCGen( shader , position );
m_D3DRender->RenderTransMDLCustom( shader , mesh->offsetVB , mesh->numVertices , mesh->offsetEB , mesh->numElems , 0xa0a0a0a0 );
}
else
{
m_D3DRender->SetTexture( 0 , m_texMng->GetD3DTexture( mdl->m_shaderRefs[ mesh->skinInfo ].shader ) );
m_D3DRender->RenderTransDefault( mesh->offsetVB , mesh->numVertices , mesh->offsetEB , mesh->numElems , 0xa0a0a0a0 );
}
m_totalRenderPolygon += mdl->m_meshes[k].numElems / 3;
}
mdlWorldEntity = mdlWorldEntity->blendNext;
}
}
}
} | C++ |
#if !defined(AFX_MDLMNG_H__86623AB5_EAFE_455F_BA31_CAACB52436A6__INCLUDED_)
#define AFX_MDLMNG_H__86623AB5_EAFE_455F_BA31_CAACB52436A6__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#define GTH_MODEL_FORMAT ( GTH_FORMAT_XYZ | GTH_FORMAT_NORMAL | GTH_FORMAT_TEXVERTEX( 1 ) )
#define MAX_SIZE_MDL_STATIC_VERTEX_BUFFER_BANK 16
#define MAX_SIZE_MDL_DYNAMIC_VERTEX_BUFFER 1024 * 60
#define MAX_SIZE_MDL_DYNAMIC_INDEX_BUFFER 1024 * 180
#define MAX_SIZE_MDL_TEMP_VERTEX_BUFFER 1024 * 10
#define MAX_BANKSIZE_VERTEXBUFFER 1024 * 64
#define MAX_SIZE_MDL 600
#define WORLD_ENTITY_MAX_PARTS 4
#define ITEM_ENTITY_MAX_PARTS 4
#define EFFECT_ENTITY_MAX_PARTS 16
#define EFFECT_ENTITY_MAX_STATES 4
#define MAX_SIZE_MDL_WORLD_CLASS 256
#define MAX_SIZE_MDL_ITEM_CLASS 256
#define MAX_SIZE_MDL_EFFECT_CLASS 256
#define MAX_SIZE_MDL_WORLD_ENTITY 1024
#define MAX_SIZE_MDL_ITEM_ENTITY 128
#define MAX_SIZE_MDL_EFFECT_ENTITY 1024
typedef enum
{
GTH_ANIM_PLAY_ONCE = 0 ,
GTH_ANIM_PLAY_LOOP ,
GTH_ANIM_PLAY_TIME
} GTH_ANIM_PLAY_TYPE;
typedef enum
{
GTH_SYNC_APPTIME = 0 ,
GTH_SYNC_EVENT ,
GTH_SYNC_ANIMATION
} GTH_SYNC_TYPE;
typedef enum
{
GTH_WORLD_ENTITY_TYPE_NONE = 0 ,
GTH_WORLD_ENTITY_TYPE_MODEL ,
GTH_WORLD_ENTITY_TYPE_PLAYER_POS ,
GTH_WORLD_ENTITY_TYPE_TELEPORT ,
GTH_WORLD_ENTITY_TYPE_ACTIVATOR ,
GTH_WORLD_ENTITY_TYPE_DEACTIVATOR ,
GTH_WORLD_ENTITY_TYPE_DOOR ,
GTH_WORLD_ENTITY_TYPE_PATH ,
GTH_WORLD_ENTITY_TYPE_CAMERA_PATH ,
GTH_WORLD_ENTITY_TYPE_SOUND
} GTH_WORLD_ENTITY_TYPE;
typedef struct mdlworldentity_s
{
vec3_t origin;
float rotate;
vec3_t mins;
vec3_t maxs;
int idxClass;
int visible;
vec3_t *collisionVertex [WORLD_ENTITY_MAX_PARTS];
int num_cvertex[WORLD_ENTITY_MAX_PARTS];
mdlworldentity_s *next;
mdlworldentity_s *prev;
mdlworldentity_s *renderNext;
mdlworldentity_s *blendNext;
} mdlworldentity_t;
typedef struct
{
char mdlName[64];
char tagName[32];
float msecPerFrame;
float rotSpeed;
float scale;
int mdlIdx;
int onlyTag;
} mdlworldclasspart_t;
typedef struct
{
int classType;
char itemName[64];
int loaded;
int numParts;
float bobHeight;
float bobSpeed;
vec3_t mins;
vec3_t maxs;
mdlworldclasspart_t parts[ WORLD_ENTITY_MAX_PARTS ];
int hideFlag;
} mdlworldclass_t;
typedef struct
{
int idxClass;
mdlworldentity_t *linked;
} mdlworldentitylink_t;
typedef enum
{
GTH_ITEM_CLASS_NONE = 0 ,
GTH_ITEM_CLASS_WEAPON ,
GTH_ITEM_CLASS_UPPER ,
GTH_ITEM_CLASS_LOWER ,
GTH_ITEM_CLASS_PROTECTOR ,
GTH_ITEM_CLASS_HAND ,
GTH_ITEM_CLASS_FOOT ,
GTH_ITEM_CLASS_AIR_PROTECTOR ,
GTH_ITEM_CLASS_ACCESSORY,
GTH_ITEM_CLASS_RESERVED
} GTH_ITEM_CLASS_TYPE;
typedef struct mdlitementity_s
{
vec3_t origin;
float rotate;
vec3_t mins;
vec3_t maxs;
int idxClass;
int visible;
GTH_SYNC_TYPE syncType;
GTH_ANIM_PLAY_TYPE animType;
float animTime;
mdlitementity_s *next;
mdlitementity_s *prev;
} mdlitementity_t;
typedef struct
{
char mdlName[64];
char tagName[32];
float msecPerFrame;
float rotSpeed;
float scale;
int mdlIdx;
int onlyTag;
vec3_t color;
} mdlitemclasspart_t;
typedef struct
{
char className[64];
int classType;
char itemName[64];
int itemID;
int loaded;
int numParts;
float bobHeight;
float bobSpeed;
vec3_t mins;
vec3_t maxs;
mdlitemclasspart_t parts[ ITEM_ENTITY_MAX_PARTS ];
} mdlitemclass_t;
typedef struct
{
int idxClass;
mdlitementity_t *linked;
} mdlitementitylink_t;
typedef enum
{
GTH_EFFECT_CLASS_NONE = 0 ,
GTH_EFFECT_CLASS_MODEL ,
GTH_EFFECT_CLASS_MULTI_MODEL ,
GTH_EFFECT_CLASS_POINTER
} GTH_EFFECT_CLASS_TYPE;
typedef struct mdleffectentity_s
{
vec3_t origin;
vec3_t target;
vec3_t angles;
vec3_t mins;
vec3_t maxs;
bool m_SendAttackMessage;
int idxEntity;
int idxClass;
int visible;
float startTime;
float completeTime;
float animTime;
int state;
int firedStep;
float firedScale;
float hitDiff;
int effect_level;
vec3_t offset;
int follow_attacker;
int attackerIdx;
int attackerType;
int defenderIdx;
int defenderType;
float lifeTime;
bool soundflag [EFFECT_ENTITY_MAX_STATES][EFFECT_ENTITY_MAX_PARTS];
float velocity;
float backup_startTime;
vec3_t backup_origin;
vec3_t backup_angles;
mdleffectentity_s *next;
mdleffectentity_s *prev;
int effectID;
} mdleffectentity_t;
#define GTH_EFFECT_STATE_NORMAL 0
#define GTH_EFFECT_STATE_ARMED 0
#define GTH_EFFECT_STATE_FIRED 1
#define GTH_EFFECT_STATE_HITTED 2
#define GTH_EFFECT_STATE_MISSED 3
#define GTH_EFFECT_NOT_COMPLETED 0
#define GTH_EFFECT_ALL_STATE_COMPLETED 1
#define GTH_EFFECT_ARMED_STATE_COMPLETED 2
#define GTH_EFFECT_FIRED_STATE_COMPLETED 3
#define GTH_EFFECT_ERROR 4
#define MAX_SIZE_GTH_EFFECT_CLASS_STATE 4
#define GTH_EFFECT_ANIMTIME_FULL -1.0f
#define GTH_EFFECT_FIRED_STEP_COMPLETE 4
#define GTH_EFFECT_FIRED_STEP_DIVINE 0.25f
#define GTH_EFFECT_HIT_STEP_COMPLETE 50
#define GTH_EFFECT_HIT_STEP_DIVINE 0.02f
#define MAX_SIZE_EFFECT_LEVEL 8
typedef struct
{
char mdlName[64];
char tagName[32];
float startTime;
float endTime;
float msecPerFrame;
float rotSpeed;
float scale;
int mdlIdx;
int onlyTag;
int numFrames;
vec3_t offset;
vec3_t angleOffset;
float selfRotSpeed;
int req_level;
int billboard;
} mdleffectclasspart_t;
typedef struct
{
int state;
int numParts;
float bobHeight;
float bobSpeed;
float completeTime[MAX_SIZE_EFFECT_LEVEL];
float normalSize;
int soundID;
int loaded;
int projectile;
float projectileHeight;
float startTime;
vec3_t mins;
vec3_t maxs;
int setground;
mdleffectclasspart_t parts[ EFFECT_ENTITY_MAX_PARTS ];
} mdleffectclassstate_t;
typedef struct
{
int classType;
char effectName[64];
int effectID;
int loaded;
float completeTime;
mdleffectclassstate_t states[ EFFECT_ENTITY_MAX_STATES ];
char effectDesc[256];
int maxLevel;
int inuse;
} mdleffectclass_t;
typedef struct
{
int idxClass;
mdleffectentity_t *linked;
} mdleffectentitylink_t;
typedef struct
{
int worldClasses [ MAX_SIZE_MDL_WORLD_CLASS ];
int itemClasses [ MAX_SIZE_MDL_ITEM_CLASS ];
int effectClasses[ MAX_SIZE_MDL_EFFECT_CLASS ];
} linkedcount_t;
struct Fx_CHARACTER_t;
class CMDLMng
{
public:
CMDL m_MDLs[ MAX_SIZE_MDL ];
mdlworldclass_t m_MDLWorldClasses [ MAX_SIZE_MDL_WORLD_CLASS ];
mdlitemclass_t m_MDLItemClasses [ MAX_SIZE_MDL_ITEM_CLASS ];
mdleffectclass_t m_MDLEffectClasses[ MAX_SIZE_MDL_EFFECT_CLASS ];
mdlworldentity_t m_MDLWorldEntities [ MAX_SIZE_MDL_WORLD_ENTITY ];
mdlitementity_t m_MDLItemEntities [ MAX_SIZE_MDL_ITEM_ENTITY ];
mdleffectentity_t m_MDLEffectEntities[ MAX_SIZE_MDL_EFFECT_ENTITY ];
mdlworldentitylink_t m_linkedMDLWorldEntities [ MAX_SIZE_MDL_WORLD_CLASS ];
mdlitementitylink_t m_linkedMDLItemEntities [ MAX_SIZE_MDL_ITEM_CLASS ];
mdleffectentitylink_t m_linkedMDLEffectEntities[ MAX_SIZE_MDL_EFFECT_CLASS ];
mdlworldentity_t *m_linkedRenderMDLWorldEntities[ MAX_SIZE_MDL_WORLD_CLASS ];
mdlworldentity_t *m_linkedBlendMDLWorldEntities [ MAX_SIZE_MDL_WORLD_CLASS ];
int m_worldInUse [ MAX_SIZE_MDL_WORLD_ENTITY ];
int m_itemInUse [ MAX_SIZE_MDL_ITEM_ENTITY ];
linkedcount_t m_linkedVisibleCount;
int m_numMDLs;
int m_numMDLWorldClasses;
int m_numMDLItemClasses;
int m_numMDLEffectClasses;
int m_currMDLWorldEntity;
int m_currMDLItemEntity;
int m_currMDLEffectEntity;
CShaderMng *m_shaderMng;
CD3DTextureMng *m_texMng;
CD3DRender *m_D3DRender;
CTimer *m_timer;
CFileMng *m_fileMng;
CScript *m_script;
CMusicMng *m_musicMng;
LPDIRECT3DDEVICE8 m_pD3DDevice;
int m_totalRenderPolygon;
matrix4x4_t *m_envMat;
vec3_t m_camPos;
vec3_t m_camDir;
float m_currTime;
float m_currMilliTime;
int m_numBank;
int m_numStaticElems;
int m_prevNumStaticVerts;
int m_currNumStaticVerts;
CResManager m_resManager;
int m_bankSize[ MAX_SIZE_MDL_STATIC_VERTEX_BUFFER_BANK ];
CD3DBuffer *m_staticVB[ MAX_SIZE_MDL_STATIC_VERTEX_BUFFER_BANK ];
CD3DBuffer *m_dynamicVB;
CD3DBuffer *m_dynamicIB;
CD3DBuffer *m_staticEB;
BYTE *m_visData;
DWORD m_format;
int m_currBank;
wavefunc_t m_waveFunc;
matrix4x4_t m_transform;
int m_isInterpolated;
float m_interPol;
int m_currFrame;
DWORD m_frameFlag;
int m_focusedItem;
int m_focusedWorld;
int m_useFocusItem;
int m_useFocusWorld;
DWORD m_focusedItemColor;
unsigned long m_mdlRscSize;
CMDLMng();
virtual ~CMDLMng();
void SetShaderMng( CShaderMng *shaderMng ) { m_shaderMng = shaderMng; }
void SetTexMng( CD3DTextureMng *texMng ) { m_texMng = texMng; }
void SetDevice( LPDIRECT3DDEVICE8 pD3DDevice ) { m_pD3DDevice = pD3DDevice; }
void SetFileMng( CFileMng *fileMng ) { m_fileMng = fileMng; }
void SetTimer( CTimer *timer ) { m_timer = timer; }
void SetRenderer( CD3DRender *d3dRender ) { m_D3DRender = d3dRender; }
void SetScript( CScript *script ) { m_script = script; }
void SetEnvironmentMatrix( matrix4x4_t *mat ) { m_envMat = mat; }
void SetVisData( BYTE *vis ) { m_visData = vis; }
void SetFrameFlag( DWORD frameFlag ) { m_frameFlag = frameFlag; }
void SetMusicMng( CMusicMng *musicMng ) { m_musicMng = musicMng; }
void SetCamera( vec3_t pos , vec3_t dir );
void SetFocusedItemColor( int alpha , int red , int green , int blue ) { m_focusedItemColor = MAKE_COLOR_ARGB( alpha , red , green , blue ); }
void SetFocusItemUsage( int usage ) { m_useFocusItem = usage; }
void SetFocusWorldUsage( int usage ) { m_useFocusWorld = usage; }
void Release();
int PrepareMDLShader();
int Initialize();
int Restore( LPDIRECT3DDEVICE8 pD3DDevice );
int GenDynamicMem();
void PrepareVertexBuffer();
int UploadVertexBuffer();
int LoadMDL( char *MDLName );
CMDL* GetMDL( int mdlIdx );
int PrepareMDLShader( int mdlIdx );
void CalcVertexBuffer( CMDL *mdl );
void EndOfCalcVertexBuffer();
void RestoreVertexInfo( int mdlIdx );
int LoadWorldClass( char *fname );
void ParseWorldClassPart( mdlworldclasspart_t *part );
void ParseWorldClassToken( mdlworldclass_t *mdlClass , char *token );
int GetWorldClassType( char *token );
int LinkMDLWorldClass( int idxMDLClass );
void SetMDLWorldEntityOrigin( int idxMDLEntity , vec3_t origin );
void SetMDLWorldEntityAngles( int idxMDLEntity , vec3_t angles );
mdlworldentity_t *GetMDLWorldEntity( int idxMDLEntity );
mdlworldentitylink_t *GetLinkedMDLWorldEntity( int idxClass );
void RenderWorldEntity();
void RenderBlendWorldEntity();
void MakeTransformedMDL( mdlworldentity_t *entity, int idxClass );
int AddWorldEntity( char *itemName , vec3_t origin , vec3_t angles );
int DeleteWorldEntity( int idxMDLEntity );
void ClearWorldUseFlag();
void CalcWorldBoundBox( mdlworldclass_t *mdlWorldClass );
int GetMDLWorldClassBoundBox( int idxMDLEntity , vec3_t mins , vec3_t maxs );
int LoadItemClass( char *fname );
void ParseItemClassPart( mdlitemclasspart_t *part );
void ParseItemClassToken( mdlitemclass_t *mdlClass , char *token );
int GetItemClassType( char *token );
int LinkMDLItemClass( int idxMDLClass );
void SetMDLItemEntityOrigin( int idxMDLEntity , vec3_t origin );
void SetMDLItemEntityAngles( int idxMDLEntity , vec3_t angles );
mdlitementity_t *GetMDLItemEntity( int idxMDLEntity );
mdlitementitylink_t *GetLinkedMDLItemEntity( int idxClass );
void RenderItemEntity();
int InitItemClass();
int AddItemEntity( GTH_ITEM_CLASS_TYPE classType , int itemID , vec3_t origin , vec3_t angles
, GTH_SYNC_TYPE syncType = GTH_SYNC_APPTIME
, GTH_ANIM_PLAY_TYPE animType = GTH_ANIM_PLAY_LOOP , float animTime = 0.0f );
int DeleteItemEntity( int idxMDLEntity );
void ClearItemUseFlag();
void CalcItemBoundBox( mdlitemclass_t *mdlItemClass );
int GetMDLItemClassBoundBox( int idxMDLEntity , vec3_t mins , vec3_t maxs );
int LoadEffectClass( char *fname );
void ParseEffectClassState( mdleffectclassstate_t *destState );
void ParseEffectClassPart( mdleffectclasspart_t *part );
void ParseEffectClassToken( mdleffectclass_t *mdlClass , char *token );
int GetEffectClassStateType( char *token );
float GetEffectClassAnimTime( char *token );
int GetEffectClassType( char *token );
int LinkMDLEffectClass( int idxMDLClass );
void SetMDLEffectEntityOrigin( int idxMDLEntity , vec3_t origin );
void SetMDLEffectEntityAngles( int idxMDLEntity , vec3_t angles );
mdleffectentity_t *GetMDLEffectEntity( int idxMDLEntity );
mdleffectentitylink_t *GetLinkedMDLEffectEntity( int idxClass );
void RenderEffectEntity();
int InitEffectClass();
int AddEffectEntity( int entityIndex, GTH_EFFECT_CLASS_TYPE classType, int effectID, vec3_t origin, vec3_t target,
vec3_t angles, float hitDiff, int effect_level = 0, int follow_attacker = false,
int attackerIdx = -1, int attackerType = -1, int defenderIdx = -1, int defenderType = -1,
float offset_x = 0.0f, float offset_y = 0.0f, float offset_z = 0.0f, float in_lifeTime = -1.0f, int in_follow_repetition = true );
int DeleteEffectEntity( int idxMDLEntity );
void ClearEffectUseFlag();
void CalcEffectBoundBox( mdleffectclassstate_t *state );
int GetMDLEffectClassBoundBox( int idxMDLEntity , int state , vec3_t mins , vec3_t maxs );
float GetEffectStateCompleteTime( int idxClass , int state , float startTime, int effect_level = 0 );
int IsOverEffectCompleteTime( int idxMDLEntity );
void SetEffectTarget( mdleffectentity_t *mdlEntity , vec3_t target , vec3_t angles );
int SetFiredState( int idxMDLEntity , vec3_t target , vec3_t mins , vec3_t maxs );
int SetHittedState( int idxMDLEntity , vec3_t target , vec3_t mins , vec3_t maxs );
int SetMissedState( int idxMDLEntity , vec3_t target , vec3_t mins , vec3_t maxs );
void ClearClassSoundFlag( mdleffectclass_t *effectclass );
void Render();
void PrepareInterpolateMDL( CMDL *mdl , mdlmesh_t *mesh );
void PrepareMDL( CMDL *mdl , mdlmesh_t *mesh );
void RenderBound( CMDL *mdl );
void PrepareTCGenMDLMesh( CMDL *mdl , mdlmesh_t *mesh );
void PrepareMDLMesh( CMDL *mdl , mdlmesh_t *mesh );
void PrepareInterpolateTCGenMDLMesh( CMDL *mdl , mdlmesh_t *mesh );
void PrepareInterpolateMDLMesh( CMDL *mdl , mdlmesh_t *mesh );
void RenderBBox( vec3_t mins , vec3_t maxs );
void ClearItemLinkedCount();
void ClearEffectLinkedCount();
void ClearRenderWorldLink();
void ClearBlendWorldLink();
int *GetWorldVisibleLinkedCount() { return m_linkedVisibleCount.worldClasses; }
int *GetItemVisibleLinkedCount() { return m_linkedVisibleCount.itemClasses; }
int *GetEffectVisibleLinkedCount() { return m_linkedVisibleCount.effectClasses; }
void BindSoundSample ();
int IsOverEffectCompleteTime_Neo ( int idxMDLEntity, bool &processDamage, bool &sendAttackMessage );
int SetFiredState_Neo ( int idxMDLEntity, vec3_t target, vec3_t mins, vec3_t maxs );
int SetHittedState_Neo ( int idxMDLEntity, vec3_t target, vec3_t mins, vec3_t maxs );
int SetMissedState_Neo ( int idxMDLEntity, vec3_t target, vec3_t mins, vec3_t maxs );
void RenderEffectEntity_Neo ();
mdleffectentity_t* DeleteEffectManagerEntity ( mdleffectentity_t *in_entity );
bool RenderEffectPreCheck ( mdleffectentity_t **in_entity, Fx_CHARACTER_t **out_attacker, Fx_CHARACTER_t **out_defender );
float RenderEffectEvaluateFunction ( mdleffectclassstate_t *in_classState );
bool RenderEffectCheckRenderCondition ( mdleffectclasspart_t *in_classPart, Fx_CHARACTER_t *in_attacker, Fx_CHARACTER_t *in_defender, int in_followAttacker,
int in_state, int in_effectLevel, float in_startTime, float &in_partStartTime );
void RenderEffectPlaySound ( bool in_soundflag[][EFFECT_ENTITY_MAX_PARTS], vec3_t in_origin, int in_state, CMDL *in_mdl, int in_subindex );
void RenderEffectCalcCurrentFrame ( CMDL *in_mdl, mdleffectclasspart_t *in_classPart, float in_startTime, float in_partStartTime );
void RenderEffectPrepareBuffers ( CMDL *in_mdl );
bool RenderEffectSetTransform ( mdleffectclasspart_t *in_classPart, int in_followAttacker, vec3_t in_offset, int in_state, vec3_t in_origin, vec3_t in_angles,
mdleffectclassstate_t *in_classState, Fx_CHARACTER_t *in_attacker, Fx_CHARACTER_t *in_defender, vec3_t out_position, float in_bob );
void RenderEffectDoRender ( CMDL *in_mdl, vec3_t in_position );
};
#endif
| C++ |
#include "../global_def.h"
void CMDLMng::SetCamera( vec3_t pos , vec3_t dir )
{
VectorCopy( m_camPos , pos );
VectorCopy( m_camDir , dir );
}
void CMDLMng::Render()
{
m_totalRenderPolygon = 0;
m_currBank = -1;
m_D3DRender->SetVertexShader( m_format );
m_dynamicIB->Discard();
m_dynamicVB->Discard();
m_currTime += m_timer->GetElapsedTime();
m_currMilliTime += m_timer->GetElapsedMilliTime();
m_D3DRender->SetMDLRenderState();
m_waveFunc.type = WAVE_SIN;
m_waveFunc.base = 0.0f;
m_waveFunc.phase = 0.0f;
RenderWorldEntity();
RenderItemEntity();
RenderEffectEntity_Neo ();
RenderBlendWorldEntity();
}
void CMDLMng::RenderBound( CMDL *mdl )
{
mdlboundvertex_t *vertex;
int *elem , size;
mdlvertex_t *ptrVB;
WORD *ptrIB;
int i , baseIdxVB;
mdlboundmesh_t *mesh;
mesh = mdl->m_boundMeshes;
ptrVB = (mdlvertex_t *) m_dynamicVB->Lock( mesh->numVertices );
ptrIB = (WORD *) m_dynamicIB->Lock( mesh->numElems );
baseIdxVB = m_dynamicVB->GetBase();
vertex = mdl->m_boundVertices;
size = mesh->numVertices;
for( i = 0 ; i < size ; i++ , ptrVB++ , vertex++ )
{
VectorCopy( ptrVB->point , vertex->point );
VectorCopy( ptrVB->normal , vertex->normal );
Vector2Set( ptrVB->texUV , 0.0f , 0.0f );
}
elem = mdl->m_boundElems;
size = mesh->numElems;
for( i = 0 ; i < size ; i++ , ptrIB++ , elem++ )
*ptrIB = (WORD) ( *elem + baseIdxVB );
m_dynamicVB->Unlock();
m_dynamicIB->Unlock();
m_D3DRender->SetTexture( 0 , m_texMng->GetD3DTexture( 0 ) );
m_D3DRender->RenderDefault( m_dynamicVB->GetBase() , mesh->numVertices , m_dynamicIB->GetBase() , mesh->numElems );
}
void CMDLMng::PrepareMDL( CMDL *mdl , mdlmesh_t *mesh )
{
PrepareMDLMesh( mdl , mesh );
}
void CMDLMng::PrepareTCGenMDLMesh( CMDL *mdl , mdlmesh_t *mesh )
{
mdlvertex_t *vertex;
int *elem , numVertices , numElems;
mdlvertex_t *ptrVB , *ptrTCGenVB;
WORD *ptrIB , *ptrTCGenIB;
int i , baseIdxVB;
float m00, m10, m20;
float m01, m11, m21;
float m02, m12, m22;
m00 = m_envMat->xx, m10 = m_envMat->yx, m20 = m_envMat->zx;
m01 = m_envMat->xy, m11 = m_envMat->yy, m21 = m_envMat->zy;
m02 = m_envMat->xz, m12 = m_envMat->yz, m22 = m_envMat->zz;
ptrVB = (mdlvertex_t *) m_dynamicVB->Lock( mesh->numVertices * 2 );
ptrIB = (WORD *) m_dynamicIB->Lock( mesh->numElems * 2 );
baseIdxVB = m_dynamicVB->GetBase();
ptrTCGenVB = ptrVB + mesh->numVertices;
ptrTCGenIB = ptrIB + mesh->numElems;
vertex = &mdl->m_vertices[ mesh->vertexOffset ];
numVertices = mesh->numVertices;
for( i = 0 ; i < numVertices ; i++ , ptrVB++ , ptrTCGenVB++ , vertex++ )
{
VectorCopy( ptrVB->point , vertex->point );
VectorCopy( ptrVB->normal , vertex->normal );
Vector2Copy( ptrVB->texUV , vertex->texUV );
VectorCopy( ptrTCGenVB->point , vertex->point );
VectorCopy( ptrTCGenVB->normal , vertex->normal );
ptrTCGenVB->texUV[0] = 0.5f * ( 1.0f + ( vertex->normal[0] * m00 + vertex->normal[1] * m10 + vertex->normal[2] * m20 ) );
ptrTCGenVB->texUV[1] = 0.5f * ( 1.0f - ( vertex->normal[0] * m02 + vertex->normal[1] * m12 + vertex->normal[2] * m22 ) );
}
elem = &mdl->m_elems[ mesh->elemOffset ];
numElems = mesh->numElems;
for( i = 0 ; i < numElems ; i++ , ptrIB++ , ptrTCGenIB++ , elem++ )
{
*ptrIB = (WORD) ( *elem + baseIdxVB );
*ptrTCGenIB = (WORD) ( *elem + baseIdxVB + numVertices );
}
m_dynamicVB->Unlock();
m_dynamicIB->Unlock();
mesh->offsetVB = m_dynamicVB->GetBase();
mesh->offsetEB = m_dynamicIB->GetBase();
mesh->offsetTCGenVB = mesh->offsetVB + mesh->numVertices;
mesh->offsetTCGenEB = mesh->offsetEB + mesh->numElems;
}
void CMDLMng::PrepareMDLMesh( CMDL *mdl , mdlmesh_t *mesh )
{
mdlvertex_t *vertex;
int *elem , size;
mdlvertex_t *ptrVB;
WORD *ptrIB;
int i , baseIdxVB;
ptrVB = (mdlvertex_t *) m_dynamicVB->Lock( mesh->numVertices );
ptrIB = (WORD *) m_dynamicIB->Lock( mesh->numElems );
baseIdxVB = m_dynamicVB->GetBase();
vertex = &mdl->m_vertices[ mesh->vertexOffset ];
memcpy( ptrVB , vertex , sizeof( mdlvertex_t ) * mesh->numVertices );
elem = &mdl->m_elems[ mesh->elemOffset ];
size = mesh->numElems;
for( i = 0 ; i < size ; i++ , ptrIB++ , elem++ )
*ptrIB = (WORD) ( *elem + baseIdxVB );
m_dynamicVB->Unlock();
m_dynamicIB->Unlock();
mesh->offsetVB = m_dynamicVB->GetBase();
mesh->offsetEB = m_dynamicIB->GetBase();
mesh->offsetTCGenVB = mesh->offsetVB;
mesh->offsetTCGenEB = mesh->offsetEB;
}
void CMDLMng::PrepareInterpolateMDL( CMDL *mdl , mdlmesh_t *mesh )
{
PrepareInterpolateMDLMesh( mdl , mesh );
}
void CMDLMng::PrepareInterpolateTCGenMDLMesh( CMDL *mdl , mdlmesh_t *mesh )
{
int endFrame;
mdlvertex_t *vertexA , *vertexB;
int *elem , numVertices , numElems;
mdlvertex_t *ptrVB , *ptrTCGenVB;
WORD *ptrIB , *ptrTCGenIB;
int i , baseIdxVB;
float m00, m10, m20;
float m02, m12, m22;
vec3_t point , normal;
m00 = m_envMat->xx, m10 = m_envMat->yx, m20 = m_envMat->zx;
m02 = m_envMat->xz, m12 = m_envMat->yz, m22 = m_envMat->zz;
endFrame = m_currFrame + 1;
if( endFrame >= mesh->numMeshFrames )
endFrame -= mesh->numMeshFrames;
ptrVB = (mdlvertex_t *) m_dynamicVB->Lock( mesh->numVertices * 2 );
ptrIB = (WORD *) m_dynamicIB->Lock( mesh->numElems * 2 );
baseIdxVB = m_dynamicVB->GetBase();
ptrTCGenVB = ptrVB + mesh->numVertices;
ptrTCGenIB = ptrIB + mesh->numElems;
vertexA = &mdl->m_vertices[ mesh->vertexOffset + mesh->numVertices * m_currFrame ];
vertexB = &mdl->m_vertices[ mesh->vertexOffset + mesh->numVertices * endFrame ];
numVertices = mesh->numVertices;
for( i = 0 ; i < numVertices ; i++ , ptrVB++ , ptrTCGenVB++ , vertexA++ , vertexB++ )
{
VectorInterpolate( point , vertexA->point , vertexB->point , m_interPol );
VectorInterpolate( normal , vertexA->normal , vertexB->normal , m_interPol );
VectorCopy( ptrVB->point , point );
VectorCopy( ptrVB->normal , normal );
Vector2Copy( ptrVB->texUV , vertexA->texUV );
VectorCopy( ptrTCGenVB->point , point );
VectorCopy( ptrTCGenVB->normal , normal );
ptrTCGenVB->texUV[0] = 0.5f * ( 1.0f + ( normal[0] * m00 + normal[1] * m10 + normal[2] * m20 ) );
ptrTCGenVB->texUV[1] = 0.5f * ( 1.0f - ( normal[0] * m02 + normal[1] * m12 + normal[2] * m22 ) );
}
elem = &mdl->m_elems[ mesh->elemOffset ];
numElems = mesh->numElems;
for( i = 0 ; i < numElems ; i++ , ptrIB++ , ptrTCGenIB++ , elem++ )
{
*ptrIB = (WORD) ( *elem + baseIdxVB );
*ptrTCGenIB = (WORD) ( *elem + baseIdxVB + numVertices );
}
m_dynamicVB->Unlock();
m_dynamicIB->Unlock();
mesh->offsetVB = m_dynamicVB->GetBase();
mesh->offsetEB = m_dynamicIB->GetBase();
mesh->offsetTCGenVB = mesh->offsetVB + mesh->numVertices;
mesh->offsetTCGenEB = mesh->offsetEB + mesh->numElems;
}
void CMDLMng::PrepareInterpolateMDLMesh( CMDL *mdl , mdlmesh_t *mesh )
{
int endFrame;
mdlvertex_t *vertexA , *vertexB;
int *elem , size;
mdlvertex_t *ptrVB;
WORD *ptrIB;
int i , baseIdxVB;
ptrVB = (mdlvertex_t *) m_dynamicVB->Lock( mesh->numVertices );
ptrIB = (WORD *) m_dynamicIB->Lock( mesh->numElems );
baseIdxVB = m_dynamicVB->GetBase();
endFrame = m_currFrame + 1;
if( endFrame >= mesh->numMeshFrames )
endFrame -= mesh->numMeshFrames;
{
vertexA = &mdl->m_vertices[ mesh->vertexOffset + mesh->numVertices * m_currFrame ];
vertexB = &mdl->m_vertices[ mesh->vertexOffset + mesh->numVertices * endFrame ];
size = mesh->numVertices;
for( i = 0 ; i < size ; i++ , ptrVB++ , vertexA++ , vertexB++ )
{
VectorInterpolate( ptrVB->point , vertexA->point , vertexB->point , m_interPol );
VectorInterpolate( ptrVB->normal , vertexA->normal , vertexB->normal , m_interPol );
Vector2Copy( ptrVB->texUV , vertexA->texUV );
}
}
elem = &mdl->m_elems[ mesh->elemOffset ];
size = mesh->numElems;
for( i = 0 ; i < size ; i++ , ptrIB++ , elem++ )
*ptrIB = (WORD) ( *elem + baseIdxVB );
m_dynamicVB->Unlock();
m_dynamicIB->Unlock();
mesh->offsetVB = m_dynamicVB->GetBase();
mesh->offsetEB = m_dynamicIB->GetBase();
mesh->offsetTCGenVB = mesh->offsetVB;
mesh->offsetTCGenEB = mesh->offsetEB;
}
void CMDLMng::RenderBBox( vec3_t mins , vec3_t maxs )
{
mdlvertex_t *ptrVB;
WORD *ptrIB;
int i , baseIdxVB;
vec3_t normal;
matrix4x4_t worldMat;
WORD bboxIdx[36] = { 0, 3, 2, 0, 2, 1,
1, 5, 0, 0, 5, 4,
4, 7, 0, 0, 7, 3,
3, 7, 2, 2, 7, 6,
6, 5, 2, 2, 5, 1,
5, 6, 4, 4, 6, 7 };
ptrVB = (mdlvertex_t *) m_dynamicVB->Lock( 8 );
ptrIB = (WORD *) m_dynamicIB->Lock( 36 );
baseIdxVB = m_dynamicVB->GetBase();
VectorSet( normal , 1.0f , 1.0f , 1.0f );
VectorSet ( ptrVB->point , mins[0] , mins[1] , mins[2] );
VectorCopy( ptrVB->normal , normal );
Vector2Set( ptrVB->texUV , 0.5f , 0.5f );
ptrVB++;
VectorSet ( ptrVB->point , mins[0] , maxs[1] , mins[2] );
VectorCopy( ptrVB->normal , normal );
Vector2Set( ptrVB->texUV , 0.5f , 0.5f );
ptrVB++;
VectorSet ( ptrVB->point , maxs[0] , maxs[1] , mins[2] );
VectorCopy( ptrVB->normal , normal );
Vector2Set( ptrVB->texUV , 0.5f , 0.5f );
ptrVB++;
VectorSet ( ptrVB->point , maxs[0] , mins[1] , mins[2] );
VectorCopy( ptrVB->normal , normal );
Vector2Set( ptrVB->texUV , 0.5f , 0.5f );
ptrVB++;
VectorSet ( ptrVB->point , mins[0] , mins[1] , maxs[2] );
VectorCopy( ptrVB->normal , normal );
Vector2Set( ptrVB->texUV , 0.5f , 0.5f );
ptrVB++;
VectorSet ( ptrVB->point , mins[0] , maxs[1] , maxs[2] );
VectorCopy( ptrVB->normal , normal );
Vector2Set( ptrVB->texUV , 0.5f , 0.5f );
ptrVB++;
VectorSet ( ptrVB->point , maxs[0] , maxs[1] , maxs[2] );
VectorCopy( ptrVB->normal , normal );
Vector2Set( ptrVB->texUV , 0.5f , 0.5f );
ptrVB++;
VectorSet ( ptrVB->point , maxs[0] , mins[1] , maxs[2] );
VectorCopy( ptrVB->normal , normal );
Vector2Set( ptrVB->texUV , 0.5f , 0.5f );
for( i = 0 ; i < 36 ; i++ , ptrIB++ )
*ptrIB = (WORD) ( bboxIdx[i] + baseIdxVB );
m_dynamicVB->Unlock();
m_dynamicIB->Unlock();
LPDIRECT3DDEVICE8 pd3dDevice = g_d3dDevice.GetD3DDevice();
worldMat.Identity();
m_D3DRender->SetTransform( D3DTS_WORLD , &worldMat );
m_D3DRender->SetVertexShader( m_format );
m_D3DRender->SetMDLRenderState();
m_D3DRender->SetStreamSource( 0 , m_dynamicVB->GetD3DVertexBuffer() , m_dynamicVB->GetStrideSize() );
m_D3DRender->SetIndices( m_dynamicIB->GetD3DIndexBuffer() , 0 );
pd3dDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_WIREFRAME );
m_D3DRender->SetTexture( 0 , m_texMng->GetD3DTexture( 0 ) );
m_D3DRender->RenderDefault( m_dynamicVB->GetBase() , 8 , m_dynamicIB->GetBase() , 36 );
ptrVB = (mdlvertex_t *) m_dynamicVB->Lock( 2 );
VectorSet ( ptrVB->point , mins[0] , mins[1] , mins[2] );
VectorCopy( ptrVB->normal , normal );
Vector2Set( ptrVB->texUV , 0.5f , 0.5f );
ptrVB++;
VectorSet ( ptrVB->point , maxs[0] , maxs[1] , maxs[2] );
VectorCopy( ptrVB->normal , normal );
Vector2Set( ptrVB->texUV , 0.5f , 0.5f );
m_dynamicVB->Unlock();
float PointSize = 10.0f;
pd3dDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_POINT);
pd3dDevice->SetRenderState(D3DRS_POINTSIZE, *((DWORD*)&PointSize));
pd3dDevice->DrawPrimitive( D3DPT_POINTLIST , m_dynamicVB->GetBase() , 2 );
pd3dDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
}
void CMDLMng::ClearItemLinkedCount()
{
memset( m_linkedVisibleCount.itemClasses , 0 , sizeof( int ) * m_numMDLItemClasses );
}
void CMDLMng::ClearEffectLinkedCount()
{
memset( m_linkedVisibleCount.effectClasses , 0 , sizeof( int ) * m_numMDLEffectClasses );
}
void CMDLMng::ClearRenderWorldLink()
{
memset( m_linkedRenderMDLWorldEntities , 0 , sizeof( mdlworldentity_t * ) * m_numMDLWorldClasses );
}
void CMDLMng::ClearBlendWorldLink()
{
memset( m_linkedBlendMDLWorldEntities , 0 , sizeof( mdlworldentity_t * ) * m_numMDLWorldClasses );
} | C++ |
#include "../global_def.h"
int CMDLMng::LoadItemClass( char *fname )
{
char *token;
mdlitemclass_t *mdlItemClass;
mdlitemclasspart_t *part;
if( !m_script->Load( fname ) )
return false;
m_script->BeginParse();
while( 1 )
{
token = m_script->GetNextToken( true );
if( !token[0] ) break;
if( token[0] != '{' ) continue;
if( m_numMDLItemClasses >= MAX_SIZE_MDL_WORLD_CLASS )
{
GTH_ERROR( GTH_ERROR_PRINT , "MDL Item Class overflow.." );
break;
}
mdlItemClass = &m_MDLItemClasses[ m_numMDLItemClasses++ ];
mdlItemClass->numParts = 0;
memset( mdlItemClass , 0 , sizeof( mdlitemclass_t ) );
while( 1 )
{
token = m_script->GetNextToken( true );
if( !token[0] ) break;
if (token[0] == '{')
{
part = &mdlItemClass->parts[ mdlItemClass->numParts++ ];
ParseItemClassPart( part );
}
else if (token[0] == '}')
break;
else
ParseItemClassToken( mdlItemClass , token );
}
}
return true;
}
void CMDLMng::ParseItemClassPart( mdlitemclasspart_t *part )
{
char *token , *param;
part->mdlIdx = -1;
VectorSet( part->color , 1.0f , 1.0f , 1.0f );
part->msecPerFrame = 100.0f;
part->scale = 1.0f;
part->rotSpeed = 0.0f;
while( 1 )
{
token = m_script->GetNextToken( true );
if( !token[0] ) break;
if( token[0] == '}' )
{
break;
}
else if( !stricmp( token , "model" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
strcpy( part->mdlName , param );
}
else if( !stricmp( token , "scale" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->scale = (float) atof( param );
}
else if( !stricmp( token , "rotate_speed" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->rotSpeed = (float) atof( param );
}
else if( !stricmp( token , "tag" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
strcpy( part->tagName , param );
}
else if( !stricmp( token , "frame_per_second" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->msecPerFrame = (float) atof( param );
if( part->msecPerFrame > 1.0f )
part->msecPerFrame = 1000.0f / part->msecPerFrame;
}
else if( !stricmp( token , "color" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->color[0] = 255.0f / (float) atof( param );
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->color[1] = 255.0f / (float) atof( param );
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->color[2] = 255.0f / (float) atof( param );
}
m_script->SkipLine();
}
}
void CMDLMng::ParseItemClassToken( mdlitemclass_t *mdlItemClass , char *token )
{
char *param;
if( !stricmp( token , "classtype" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
mdlItemClass->classType = GetItemClassType( param );
}
else if( !stricmp( token , "height" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
mdlItemClass->bobHeight = (float) atof( param );
}
else if( !stricmp( token , "speed" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
mdlItemClass->bobSpeed = (float) atof( param );
}
else if( !stricmp( token , "itemname" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
strcpy( mdlItemClass->itemName , param );
}
else if( !stricmp( token , "itemid" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
mdlItemClass->itemID = (int) atoi( param );
}
m_script->SkipLine();
}
int CMDLMng::GetItemClassType( char *token )
{
if( !stricmp( token , "gth_item_weapon" ) )
return GTH_ITEM_CLASS_WEAPON;
else if( !stricmp( token , "gth_item_upper" ) )
return GTH_ITEM_CLASS_UPPER;
else if( !stricmp( token , "gth_item_lower" ) )
return GTH_ITEM_CLASS_LOWER;
else if( !stricmp( token , "gth_item_protector" ) )
return GTH_ITEM_CLASS_PROTECTOR;
else if( !stricmp( token , "gth_item_hand" ) )
return GTH_ITEM_CLASS_HAND;
else if( !stricmp( token , "gth_item_foot" ) )
return GTH_ITEM_CLASS_FOOT;
else if( !stricmp( token , "gth_item_air_protector" ) )
return GTH_ITEM_CLASS_AIR_PROTECTOR;
else if( !stricmp( token , "gth_item_accessory" ) )
return GTH_ITEM_CLASS_ACCESSORY;
else if( !stricmp( token , "gth_item_reserved" ) )
return GTH_ITEM_CLASS_RESERVED;
return GTH_ITEM_CLASS_NONE;
}
int CMDLMng::LinkMDLItemClass( int idxMDLClass )
{
int i;
mdlitemclass_t *mdlItemClass;
mdlitemclasspart_t *part;
int flag;
mdlItemClass = &m_MDLItemClasses[idxMDLClass];
if( mdlItemClass->loaded ) return true;
flag = true;
part = &mdlItemClass->parts[0];
for( i = 0 ; i < mdlItemClass->numParts ; i++ , part++ )
{
if( part->tagName[0] )
{
if( !stricmp( part->tagName , "tag_hand" ) )
part->onlyTag = true;
}
part->mdlIdx = LoadMDL( part->mdlName );
if( part->mdlIdx < 0 )
{
flag = false;
break;
}
}
if( flag )
CalcItemBoundBox( mdlItemClass );
mdlItemClass->loaded = flag;
return flag;
}
void CMDLMng::CalcItemBoundBox( mdlitemclass_t *mdlItemClass )
{
mdlitemclasspart_t *part;
vec3_t classMins , classMaxs;
vec3_t partMins , partMaxs;
CMDL *mdl;
int i;
ClearBounds( classMins , classMaxs );
part = &mdlItemClass->parts[0];
for( i = 0 ; i < mdlItemClass->numParts ; i++ , part++ )
{
mdl = GetMDL( part->mdlIdx );
if( mdl == NULL ) continue;
VectorCopy( partMins , mdl->m_mins );
VectorCopy( partMaxs , mdl->m_maxs );
if( part->rotSpeed != 0.0f )
{
CalcSphereBoundBox( partMins , partMaxs );
}
VectorScale( partMins , partMins , part->scale );
VectorScale( partMaxs , partMaxs , part->scale );
AddPointToBounds( partMins , classMins , classMaxs );
AddPointToBounds( partMaxs , classMins , classMaxs );
}
if( mdlItemClass->bobSpeed != 0.0f )
{
classMins[2] -= mdlItemClass->bobHeight;
classMaxs[2] += mdlItemClass->bobHeight;
}
VectorCopy( mdlItemClass->mins , classMins );
VectorCopy( mdlItemClass->maxs , classMaxs );
}
int CMDLMng::InitItemClass()
{
for( int i = 0 ; i < m_numMDLItemClasses ; i++ )
{
LinkMDLItemClass( i );
}
memset( m_linkedMDLItemEntities , 0 , sizeof( mdlitementitylink_t ) * MAX_SIZE_MDL_ITEM_CLASS );
memset( m_MDLItemEntities , 0 , sizeof( mdlitementity_t ) * MAX_SIZE_MDL_ITEM_ENTITY );
memset( m_itemInUse , 0 , sizeof( int ) * MAX_SIZE_MDL_ITEM_ENTITY );
m_currMDLItemEntity = 0;
return true;
}
void CMDLMng::ClearItemUseFlag()
{
memset( m_linkedMDLItemEntities , 0 , sizeof( mdlitementitylink_t ) * m_numMDLItemClasses );
memset( m_itemInUse , 0 , sizeof( int ) * MAX_SIZE_MDL_ITEM_ENTITY );
m_currMDLItemEntity = 0;
}
int CMDLMng::AddItemEntity( GTH_ITEM_CLASS_TYPE classType , int itemID , vec3_t origin , vec3_t angles
, GTH_SYNC_TYPE syncType , GTH_ANIM_PLAY_TYPE animType , float animTime )
{
mdlitemclass_t *mdlItemClass;
mdlitementity_t *mdlEntity;
mdlitementitylink_t *linkedMDLEntity;
int i;
int idxClass , found;
if( classType == GTH_ITEM_CLASS_NONE ) return -1;
mdlItemClass = &m_MDLItemClasses[0];
for( i = 0 ; i < m_numMDLItemClasses ; i++ , mdlItemClass++ )
{
if( mdlItemClass->classType == classType && mdlItemClass->itemID == itemID )
{
idxClass = i;
break;
}
}
if( i == m_numMDLItemClasses ) return -1;
if( !mdlItemClass->loaded ) return -1;
found = -1;
for( i = m_currMDLItemEntity ; i < MAX_SIZE_MDL_ITEM_ENTITY ; i++ )
{
if( !m_itemInUse[i] )
{
found = i;
goto NEXT_FREE_MDL_ITEM_ENTITY;
}
}
for( i = 0 ; i < m_currMDLItemEntity ; i++ )
{
if( !m_itemInUse[i] )
{
found = i;
goto NEXT_FREE_MDL_ITEM_ENTITY;
}
}
if( found == -1 )
{
found = m_currMDLItemEntity + 1;
if( found >= MAX_SIZE_MDL_ITEM_ENTITY )
found = 0;
DeleteItemEntity( found );
}
NEXT_FREE_MDL_ITEM_ENTITY :
m_currMDLItemEntity = found;
mdlEntity = &m_MDLItemEntities[ m_currMDLItemEntity ];
linkedMDLEntity = &m_linkedMDLItemEntities[ idxClass ];
mdlEntity->idxClass = idxClass;
mdlEntity->next = linkedMDLEntity->linked;
mdlEntity->prev = NULL;
if( linkedMDLEntity->linked )
linkedMDLEntity->linked->prev = mdlEntity;
linkedMDLEntity->linked = mdlEntity;
VectorCopy( mdlEntity->origin , origin );
mdlEntity->rotate = angles[ YAW ];
mdlEntity->syncType = syncType;
mdlEntity->animType = animType;
mdlEntity->animTime = animTime;
mdlEntity->visible = false;
m_itemInUse[ m_currMDLItemEntity ] = true;
return m_currMDLItemEntity;
}
int CMDLMng::DeleteItemEntity( int idxMDLEntity )
{
mdlitementity_t *mdlEntity;
mdlEntity = &m_MDLItemEntities[ idxMDLEntity ];
if( !m_itemInUse[ idxMDLEntity ] ) return true;
if( mdlEntity->prev )
{
mdlEntity->prev->next = mdlEntity->next;
}
else
{
m_linkedMDLItemEntities[ mdlEntity->idxClass ].linked = mdlEntity->next;
}
if( mdlEntity->next )
mdlEntity->next->prev = mdlEntity->prev;
mdlEntity->next = NULL;
mdlEntity->prev = NULL;
m_itemInUse[ idxMDLEntity ] = false;
return true;
}
void CMDLMng::SetMDLItemEntityOrigin( int idxMDLEntity , vec3_t origin )
{
VectorCopy( m_MDLItemEntities[ idxMDLEntity ].origin , origin );
}
void CMDLMng::SetMDLItemEntityAngles( int idxMDLEntity , vec3_t angles )
{
m_MDLItemEntities[ idxMDLEntity ].rotate = angles[YAW];
}
mdlitementity_t *CMDLMng::GetMDLItemEntity( int idxMDLEntity )
{
return &m_MDLItemEntities[ idxMDLEntity ];
}
mdlitementitylink_t *CMDLMng::GetLinkedMDLItemEntity( int idxClass )
{
return &m_linkedMDLItemEntities[ idxClass ];
}
int CMDLMng::GetMDLItemClassBoundBox( int idxMDLEntity , vec3_t mins , vec3_t maxs )
{
mdlitementity_t *mdlEntity;
mdlEntity = &m_MDLItemEntities[ idxMDLEntity ];
if( !m_itemInUse[ idxMDLEntity ] ) return false;
VectorCopy( mins , m_MDLItemClasses[ mdlEntity->idxClass ].mins );
VectorCopy( maxs , m_MDLItemClasses[ mdlEntity->idxClass ].maxs );
return true;
}
void CMDLMng::RenderItemEntity()
{
int i , j , k;
mdlitementitylink_t *linked;
mdlitemclass_t *mdlItemClass;
mdlitemclasspart_t *mdlItemClassPart;
mdlitementity_t *mdlItemEntity;
CMDL *mdl;
mdlmesh_t *mesh;
float bob;
vec3_t scale , position;
matrix4x4_t tmp;
shader_t *shader;
int *linkedCount;
linked = &m_linkedMDLItemEntities[0];
mdlItemClass = &m_MDLItemClasses[0];
linkedCount = &m_linkedVisibleCount.itemClasses[0];
for( i = 0 ; i < m_numMDLItemClasses ; i++ , linked++ , linkedCount++ , mdlItemClass++ )
{
if( !linked->linked ) continue;
if( *linkedCount < 1 ) continue;
m_waveFunc.amplitude = mdlItemClass->bobHeight;
m_waveFunc.frequency = mdlItemClass->bobSpeed;
bob = m_shaderMng->EvaluateFunc( &m_waveFunc , m_currTime );
mdlItemClassPart = &mdlItemClass->parts[0];
for( j = 0 ; j < mdlItemClass->numParts ; j++ , mdlItemClassPart++ )
{
if( mdlItemClassPart->onlyTag ) continue;
mdl = GetMDL( mdlItemClassPart->mdlIdx );
if( mdl == NULL ) continue;
VectorSet( scale , mdlItemClassPart->scale , mdlItemClassPart->scale , mdlItemClassPart->scale );
if( mdl->m_numBoneFrames > 1 )
{
m_isInterpolated = true;
m_interPol = m_currMilliTime / mdlItemClassPart->msecPerFrame;
m_currFrame = ( (int) m_interPol ) % ( mdl->m_numBoneFrames - 1 );
m_interPol = m_interPol - ( (int) m_interPol );
}
else
{
m_isInterpolated = false;
m_interPol = 0.0f;
m_currFrame = 0;
}
if( m_isInterpolated )
{
for( k = 0 ; k < mdl->m_numMeshes ; k++ )
PrepareInterpolateMDL( mdl , &mdl->m_meshes[k] );
m_D3DRender->SetStreamSource( 0 , m_dynamicVB->GetD3DVertexBuffer() , m_dynamicVB->GetStrideSize() );
m_D3DRender->SetIndices( m_dynamicIB->GetD3DIndexBuffer() , 0 );
m_currBank = -1;
}
else
{
if( mdl->m_needDynVB )
{
for( k = 0 ; k < mdl->m_numMeshes ; k++ )
PrepareMDL( mdl , &mdl->m_meshes[k] );
m_D3DRender->SetStreamSource( 0 , m_dynamicVB->GetD3DVertexBuffer() , m_dynamicVB->GetStrideSize() );
m_D3DRender->SetIndices( m_dynamicIB->GetD3DIndexBuffer() , 0 );
m_currBank = -1;
}
else
{
if( m_currBank != mdl->m_bank )
{
m_D3DRender->SetStreamSource( 0 , m_staticVB[ mdl->m_bank ]->GetD3DVertexBuffer()
, m_staticVB[ mdl->m_bank ]->GetStrideSize() );
m_currBank = mdl->m_bank;
}
m_D3DRender->SetIndices( m_staticEB->GetD3DIndexBuffer() , 0 );
}
}
mesh = &mdl->m_meshes[0];
for( k = 0 ; k < mdl->m_numMeshes ; k++ , mesh++ )
{
if( mdl->m_shaderRefs[ mesh->skinInfo ].isShader )
m_shaderMng->PrepareShader( mdl->m_shaderRefs[ mesh->skinInfo ].shader , m_frameFlag );
}
mdlItemEntity = linked->linked;
while( mdlItemEntity )
{
if( !mdlItemEntity->visible )
{
mdlItemEntity = mdlItemEntity->next;
continue;
}
m_transform.Identity();
VectorSet( position , mdlItemEntity->origin[0] , mdlItemEntity->origin[1] , mdlItemEntity->origin[2] + bob );
m_transform.Translate( position );
if( mdlItemClassPart->rotSpeed == 0.0f )
m_transform.RotateZ( mdlItemEntity->rotate );
else
m_transform.RotateZ( mdlItemClassPart->rotSpeed * m_currTime * 180.0f );
tmp.Scale( scale );
m_transform *= tmp;
m_D3DRender->SetTransform( D3DTS_WORLD , &m_transform );
mesh = &mdl->m_meshes[0];
for( k = 0 ; k < mdl->m_numMeshes ; k++ , mesh++ )
{
if( mdl->m_shaderRefs[ mesh->skinInfo ].isShader )
{
shader = &m_shaderMng->m_shaders[ mdl->m_shaderRefs[ mesh->skinInfo ].shader ];
if( shader->flags & SHADER_TCGEN )
m_shaderMng->PrepareTCGen( shader , position );
m_D3DRender->RenderMDLCustom( shader , mesh->offsetVB , mesh->numVertices , mesh->offsetEB , mesh->numElems );
}
else
{
m_D3DRender->SetTexture( 0 , m_texMng->GetD3DTexture( mdl->m_shaderRefs[ mesh->skinInfo ].shader ) );
m_D3DRender->RenderDefault( mesh->offsetVB , mesh->numVertices , mesh->offsetEB , mesh->numElems );
}
m_totalRenderPolygon += mdl->m_meshes[k].numElems / 3;
}
mdlItemEntity = mdlItemEntity->next;
}
}
}
if( m_focusedItem >= 0 && m_useFocusItem )
{
mdlItemEntity = &m_MDLItemEntities[ m_focusedItem ];
if( !mdlItemEntity->visible ) return;
mdlItemClass = &m_MDLItemClasses[ mdlItemEntity->idxClass ];
m_waveFunc.amplitude = mdlItemClass->bobHeight;
m_waveFunc.frequency = mdlItemClass->bobSpeed;
bob = m_shaderMng->EvaluateFunc( &m_waveFunc , m_currTime );
mdlItemClassPart = &mdlItemClass->parts[0];
for( j = 0 ; j < mdlItemClass->numParts ; j++ , mdlItemClassPart++ )
{
if( mdlItemClassPart->onlyTag ) continue;
mdl = GetMDL( mdlItemClassPart->mdlIdx );
if( mdl == NULL ) continue;
VectorSet( scale , mdlItemClassPart->scale , mdlItemClassPart->scale , mdlItemClassPart->scale );
VectorScale( scale , scale , 1.1f );
if( mdl->m_numBoneFrames > 1 )
{
m_isInterpolated = true;
m_interPol = m_currMilliTime / mdlItemClassPart->msecPerFrame;
m_currFrame = ( (int) m_interPol ) % ( mdl->m_numBoneFrames - 1 );
m_interPol = m_interPol - ( (int) m_interPol );
}
else
{
m_isInterpolated = false;
m_interPol = 0.0f;
m_currFrame = 0;
}
if( m_isInterpolated )
{
for( k = 0 ; k < mdl->m_numMeshes ; k++ )
PrepareInterpolateMDL( mdl , &mdl->m_meshes[k] );
m_D3DRender->SetStreamSource( 0 , m_dynamicVB->GetD3DVertexBuffer() , m_dynamicVB->GetStrideSize() );
m_D3DRender->SetIndices( m_dynamicIB->GetD3DIndexBuffer() , 0 );
m_currBank = -1;
}
else
{
if( mdl->m_needDynVB )
{
for( k = 0 ; k < mdl->m_numMeshes ; k++ )
PrepareMDL( mdl , &mdl->m_meshes[k] );
m_D3DRender->SetStreamSource( 0 , m_dynamicVB->GetD3DVertexBuffer() , m_dynamicVB->GetStrideSize() );
m_D3DRender->SetIndices( m_dynamicIB->GetD3DIndexBuffer() , 0 );
m_currBank = -1;
}
else
{
if( m_currBank != mdl->m_bank )
{
m_D3DRender->SetStreamSource( 0 , m_staticVB[ mdl->m_bank ]->GetD3DVertexBuffer()
, m_staticVB[ mdl->m_bank ]->GetStrideSize() );
m_currBank = mdl->m_bank;
}
m_D3DRender->SetIndices( m_staticEB->GetD3DIndexBuffer() , 0 );
}
}
m_transform.Identity();
VectorSet( position , mdlItemEntity->origin[0] , mdlItemEntity->origin[1] , mdlItemEntity->origin[2] + bob );
m_transform.Translate( position );
if( mdlItemClassPart->rotSpeed == 0.0f )
m_transform.RotateZ( mdlItemEntity->rotate );
else
m_transform.RotateZ( mdlItemClassPart->rotSpeed * m_currTime * 180.0f );
tmp.Scale( scale );
m_transform *= tmp;
m_D3DRender->SetAttachShader( m_focusedItemColor );
m_D3DRender->SetTransform( D3DTS_WORLD , &m_transform );
mesh = &mdl->m_meshes[0];
for( k = 0 ; k < mdl->m_numMeshes ; k++ , mesh++ )
{
m_D3DRender->RenderDefault( mesh->offsetVB , mesh->numVertices , mesh->offsetEB , mesh->numElems );
m_totalRenderPolygon += mdl->m_meshes[k].numElems / 3;
}
m_D3DRender->EndAttachShader();
}
}
} | C++ |
#include "../global_def.h"
bool CMDLMng::RenderEffectPreCheck ( mdleffectentity_t **in_entity,
Fx_CHARACTER_t **out_attacker,
Fx_CHARACTER_t **out_defender )
{
if ( ! (*in_entity)->visible )
{
(*in_entity) = (*in_entity)->next;
return false;
}
if ( (*in_entity)->attackerIdx >= 0 )
{
(*out_attacker) = g_charManager->FindCharacterByServerIndex( (*in_entity)->attackerIdx, (*in_entity)->attackerType );
if ( ! (*out_attacker) )
{
(*in_entity) = DeleteEffectManagerEntity( (*in_entity) );
return false;
}
}
else
{
(*out_attacker) = NULL;
}
if ( (*in_entity)->defenderIdx >= 0 )
{
(*out_defender) = g_charManager->FindCharacterByServerIndex( (*in_entity)->defenderIdx, (*in_entity)->defenderType );
if ( ! (*out_defender) )
{
(*in_entity) = DeleteEffectManagerEntity( (*in_entity) );
return false;
}
}
else
{
(*out_defender) = NULL;
}
return true;
}
float CMDLMng::RenderEffectEvaluateFunction ( mdleffectclassstate_t *in_classState )
{
m_waveFunc.amplitude = in_classState->bobHeight;
m_waveFunc.frequency = in_classState->bobSpeed;
return m_shaderMng->EvaluateFunc( &m_waveFunc, m_currTime );
}
bool CMDLMng::RenderEffectCheckRenderCondition ( mdleffectclasspart_t *in_classPart,
Fx_CHARACTER_t *in_attacker,
Fx_CHARACTER_t *in_defender,
int in_followAttacker,
int in_state,
int in_effectLevel,
float in_startTime,
float &in_partStartTime )
{
if ( in_classPart->onlyTag )
return false;
if ( in_followAttacker )
{
if ( ( in_attacker == NULL ) ||
( in_attacker ->flag_culled ) )
return false;
}
else if ( ( in_state == GTH_EFFECT_STATE_HITTED ) ||
( in_state == GTH_EFFECT_STATE_MISSED ) )
{
if ( ( in_defender == NULL ) ||
( in_defender ->flag_culled ) )
return false;
}
if ( in_classPart ->req_level < 0 )
{
if ( in_effectLevel != ( -in_classPart ->req_level - 1 ) )
return false;
}
else
{
if ( in_effectLevel < in_classPart ->req_level )
return false;
}
in_partStartTime = ( in_startTime + in_classPart ->startTime );
if ( ( m_currMilliTime - in_partStartTime ) < 0 )
return false;
if ( ( in_classPart ->endTime > 0.0f ) &&
( in_followAttacker <= 0 ) &&
( in_state != GTH_EFFECT_STATE_FIRED ) )
{
if ( m_currMilliTime > ( in_startTime + in_classPart ->endTime ) )
return false;
}
return true;
}
void CMDLMng::RenderEffectPlaySound ( bool in_soundflag[][EFFECT_ENTITY_MAX_PARTS],
vec3_t in_origin,
int in_state,
CMDL *in_mdl,
int in_subindex )
{
if ( ( in_mdl->m_soundIdx > -1 ) &&
( ! in_soundflag[ in_state ][ in_subindex ] ) )
{
g_musicMng ->PlaySample3D ( in_mdl ->m_soundIdx, GTH_SOUND_PLAY_ONCE, in_origin );
in_soundflag[ in_state ][ in_subindex ] = true;
}
}
void CMDLMng::RenderEffectCalcCurrentFrame ( CMDL *in_mdl,
mdleffectclasspart_t *in_classPart,
float in_startTime,
float in_partStartTime )
{
if ( in_mdl->m_numBoneFrames > 1 )
{
m_isInterpolated = true;
if ( in_classPart->endTime < 0 )
{
m_interPol = ( m_currMilliTime - in_partStartTime ) / in_classPart ->msecPerFrame;
}
else
{
m_interPol = ( m_currMilliTime - in_partStartTime ) / ( ( in_classPart ->endTime + in_startTime ) - in_partStartTime ) * ( in_mdl ->m_numBoneFrames - 1 );
}
m_currFrame = ( (int) m_interPol ) % ( in_mdl ->m_numBoneFrames - 1 );
m_interPol = m_interPol - ( (int) m_interPol );
}
else
{
m_isInterpolated = false;
m_interPol = 0.0f;
m_currFrame = 0;
}
}
void CMDLMng::RenderEffectPrepareBuffers ( CMDL *in_mdl )
{
int index;
if ( m_isInterpolated )
{
for ( index = 0; \
index < in_mdl->m_numMeshes; \
index++ )
PrepareInterpolateMDL( in_mdl, &in_mdl->m_meshes[ index ] );
m_D3DRender->SetStreamSource( 0, m_dynamicVB->GetD3DVertexBuffer(), m_dynamicVB->GetStrideSize() );
m_D3DRender->SetIndices( m_dynamicIB->GetD3DIndexBuffer(), 0 );
m_currBank = -1;
}
else
{
if ( in_mdl->m_needDynVB )
{
for ( index = 0; \
index < in_mdl->m_numMeshes; \
index++ )
PrepareMDL( in_mdl, &in_mdl->m_meshes[ index ] );
m_D3DRender->SetStreamSource ( 0 , m_dynamicVB ->GetD3DVertexBuffer () , m_dynamicVB ->GetStrideSize () );
m_D3DRender->SetIndices ( m_dynamicIB ->GetD3DIndexBuffer () , 0 );
m_currBank = -1;
}
else
{
if ( m_currBank != in_mdl ->m_bank )
{
m_D3DRender ->SetStreamSource ( 0 , m_staticVB [in_mdl ->m_bank] ->GetD3DVertexBuffer () , m_staticVB [in_mdl ->m_bank] ->GetStrideSize () );
m_currBank = in_mdl ->m_bank;
}
m_D3DRender ->SetIndices ( m_staticEB ->GetD3DIndexBuffer () , 0 );
}
}
}
bool CMDLMng::RenderEffectSetTransform ( mdleffectclasspart_t *in_classPart,
int in_followAttacker,
vec3_t in_offset,
int in_state,
vec3_t in_origin,
vec3_t in_angles,
mdleffectclassstate_t *in_classState,
Fx_CHARACTER_t *in_attacker,
Fx_CHARACTER_t *in_defender,
vec3_t out_position,
float in_bob )
{
vec3_t scale, angles;
matrix4x4_t selfRot;
matrix4x4_t tmp;
m_transform.Identity ();
selfRot.Identity ();
VectorSet ( angles , 0.0f , 0.0f , 0.0f );
if ( in_classPart ->selfRotSpeed == 0.0f )
angles [YAW] = 0.0f;
else
angles [YAW] = in_classPart ->selfRotSpeed * m_currTime * 180.0f;
if ( in_classPart ->billboard )
{
angles [YAW] = angles [YAW] + g_camera .m_angles [YAW] + 90.0f;
angles [PITCH] = angles [PITCH] + g_camera .m_angles [PITCH];
}
selfRot.RotateXZ ( angles );
if ( in_followAttacker )
{
vec3_t trans;
if ( in_attacker == NULL )
return false;
if ( in_classState ->setground )
{
trans [0] = in_attacker ->position [0];
trans [1] = in_attacker ->position [1];
trans [2] = in_attacker ->position [2] - in_attacker ->stat_height;
}
else
VectorCopy ( trans , in_attacker ->position );
VectorAdd ( trans , trans , in_offset );
m_transform.Translate ( trans );
}
else
{
if ( in_classState ->setground )
{
if ( ( in_state == GTH_EFFECT_STATE_HITTED ) ||
( in_state == GTH_EFFECT_STATE_MISSED ) )
{
VectorSet ( out_position , in_origin [0] , in_origin [1] , in_origin [2] - in_defender ->stat_height );
}
else if ( in_attacker )
VectorSet ( out_position , in_origin [0] , in_origin [1] , in_origin [2] - in_attacker ->stat_height );
else
VectorSet ( out_position , in_origin [0] , in_origin [1] , in_origin [2] );
}
else
{
VectorSet ( out_position , in_origin [0] , in_origin [1] , in_origin [2] + in_bob );
}
m_transform.Translate ( out_position );
}
if ( ! in_classPart ->billboard )
{
VectorCopy ( angles , in_angles );
if ( in_classPart ->rotSpeed == 0.0f )
angles [YAW] = in_angles[ YAW ];
else
angles [YAW] = in_classPart ->rotSpeed * m_currTime * 180.0f;
VectorAdd ( angles , angles , in_classPart ->angleOffset );
if ( in_state == GTH_EFFECT_STATE_FIRED )
{
m_transform.RotateXZ ( angles );
}
else
{
if ( in_followAttacker )
{
if ( in_attacker != NULL )
{
m_transform.RotateZ ( in_attacker ->angles [YAW] + 90.0f );
}
else
{
return false;
}
}
else
{
m_transform.RotateZ ( angles [YAW] );
}
}
}
m_transform.Translate ( in_classPart ->offset );
m_transform *= selfRot;
VectorSet ( scale, in_classPart ->scale, in_classPart ->scale, in_classPart ->scale );
tmp.Scale ( scale );
m_transform *= tmp;
m_D3DRender ->SetTransform ( D3DTS_WORLD , &m_transform );
return true;
}
void CMDLMng::RenderEffectDoRender ( CMDL *in_mdl,
vec3_t in_position )
{
mdlmesh_t *mesh;
shader_t *shader;
int index;
mesh = &in_mdl ->m_meshes [0];
for ( index = 0; \
index < in_mdl ->m_numMeshes; \
index++, mesh++ )
{
if ( in_mdl ->m_shaderRefs [mesh ->skinInfo].isShader )
m_shaderMng ->PrepareShader ( in_mdl ->m_shaderRefs [mesh ->skinInfo].shader, m_frameFlag );
}
mesh = &in_mdl ->m_meshes [0];
for ( index = 0; \
index < in_mdl ->m_numMeshes; \
index++ , mesh++ )
{
if ( in_mdl ->m_shaderRefs [mesh ->skinInfo].isShader )
{
shader = &m_shaderMng ->m_shaders [in_mdl ->m_shaderRefs [mesh ->skinInfo].shader];
if ( shader ->flags & SHADER_TCGEN )
m_shaderMng ->PrepareTCGen ( shader , in_position );
m_D3DRender ->RenderMDLCustom ( shader , mesh ->offsetVB , mesh ->numVertices , mesh ->offsetEB , mesh ->numElems );
}
else
{
m_D3DRender ->SetTexture ( 0 , m_texMng ->GetD3DTexture ( in_mdl ->m_shaderRefs [mesh ->skinInfo].shader ) );
m_D3DRender ->RenderDefault ( mesh ->offsetVB , mesh ->numVertices , mesh ->offsetEB , mesh ->numElems );
}
m_totalRenderPolygon += in_mdl ->m_meshes [index].numElems / 3;
}
}
void CMDLMng::RenderEffectEntity_Neo ()
{
int index, subindex;
mdleffectentitylink_t *linked;
mdleffectclass_t *effectClass;
mdleffectclassstate_t *classState;
mdleffectclasspart_t *classPart;
mdleffectentity_t *effectEntity;
CMDL *mdl;
float bob;
vec3_t position;
int *linkedCount;
Fx_CHARACTER_t *attacker;
Fx_CHARACTER_t *defender;
float partStartTime;
linked = &m_linkedMDLEffectEntities[ 0 ];
effectClass = &m_MDLEffectClasses[ 0 ];
linkedCount = &m_linkedVisibleCount.effectClasses[ 0 ];
for ( index = 0; \
index < m_numMDLEffectClasses; \
index++, linked++, linkedCount++, effectClass++ )
{
if ( ! linked ->linked ) continue;
if ( *linkedCount < 1 )
{
continue;
}
effectEntity = linked ->linked;
while ( effectEntity )
{
if ( ! RenderEffectPreCheck( &effectEntity, &attacker, &defender ) )
{
continue;
}
classState = &effectClass->states[ effectEntity->state ];
bob = RenderEffectEvaluateFunction( classState );
classPart = &classState ->parts [0];
for ( subindex = 0; \
subindex < classState ->numParts; \
subindex++, classPart++ )
{
if ( ! RenderEffectCheckRenderCondition( classPart, attacker, defender, effectEntity->follow_attacker, effectEntity->state, effectEntity->effect_level, effectEntity->startTime, partStartTime ) )
{
continue;
}
mdl = GetMDL( classPart->mdlIdx );
if( mdl == NULL ) continue;
RenderEffectPlaySound( effectEntity->soundflag, effectEntity->origin, effectEntity->state, mdl, subindex );
RenderEffectCalcCurrentFrame( mdl, classPart, effectEntity->startTime, partStartTime );
RenderEffectPrepareBuffers( mdl );
if ( ! RenderEffectSetTransform( classPart, effectEntity->follow_attacker, effectEntity->offset, effectEntity->state, effectEntity->origin, effectEntity->angles, classState, attacker, defender, position, bob ) )
{
continue;
}
RenderEffectDoRender( mdl, position );
}
if ( ( effectClass->states[ GTH_EFFECT_STATE_FIRED ].startTime < 0 ) &&
( effectEntity->state == GTH_EFFECT_STATE_FIRED ) )
{
classState = &effectClass->states[ GTH_EFFECT_STATE_ARMED ];
bob = RenderEffectEvaluateFunction( classState );
classPart = &classState ->parts [0];
for ( subindex = 0; \
subindex < classState ->numParts; \
subindex++, classPart++ )
{
if ( ! RenderEffectCheckRenderCondition( classPart, attacker, defender, effectEntity->follow_attacker, effectEntity->state, effectEntity->effect_level, effectEntity->backup_startTime, partStartTime ) )
continue;
mdl = GetMDL( classPart->mdlIdx );
if( mdl == NULL ) continue;
RenderEffectPlaySound( effectEntity->soundflag, effectEntity->backup_origin, effectEntity->state, mdl, subindex );
RenderEffectCalcCurrentFrame( mdl, classPart, effectEntity->backup_startTime, partStartTime );
RenderEffectPrepareBuffers( mdl );
if ( ! RenderEffectSetTransform( classPart, effectEntity->follow_attacker, effectEntity->offset, effectEntity->state, effectEntity->backup_origin, effectEntity->backup_angles, classState, attacker, defender, position, bob ) )
continue;
RenderEffectDoRender( mdl, position );
}
}
else if ( ( effectClass->states[ GTH_EFFECT_STATE_FIRED ].numParts <= 0 ) &&
( ( effectClass->states[ GTH_EFFECT_STATE_HITTED ].startTime < 0 ) &&
( effectEntity->state == GTH_EFFECT_STATE_HITTED ) ) )
{
classState = &effectClass->states[ GTH_EFFECT_STATE_ARMED ];
bob = RenderEffectEvaluateFunction( classState );
classPart = &classState ->parts [0];
for ( subindex = 0; \
subindex < classState ->numParts; \
subindex++, classPart++ )
{
if ( ! RenderEffectCheckRenderCondition( classPart, attacker, defender, effectEntity->follow_attacker, effectEntity->state, effectEntity->effect_level, effectEntity->backup_startTime, partStartTime ) )
continue;
mdl = GetMDL( classPart->mdlIdx );
if( mdl == NULL ) continue;
RenderEffectPlaySound( effectEntity->soundflag, effectEntity->backup_origin, effectEntity->state, mdl, subindex );
RenderEffectCalcCurrentFrame( mdl, classPart, effectEntity->backup_startTime, partStartTime );
RenderEffectPrepareBuffers( mdl );
if ( ! RenderEffectSetTransform( classPart, effectEntity->follow_attacker, effectEntity->offset, effectEntity->state, effectEntity->backup_origin, effectEntity->backup_angles, classState, attacker, defender, position, bob ) )
continue;
RenderEffectDoRender( mdl, position );
}
}
effectEntity = effectEntity->next;
}
}
} | C++ |
#include "../global_def.h"
#define MDL_PROJECTILE_SPEED 600
#define MDL_PROJECTILE_HIT_MARGIN 70
#define MDL_PROJECTILE_SEND_ATTACK_MARGIN 300
#define MDL_PROJECTILE_INITIAL_VELOCITY 400.0f
#define MDL_PROJECTILE_ACCELERATION 1500.0f
int CMDLMng::LoadEffectClass( char *fname )
{
char *token;
mdleffectclass_t *mdlEffectClass;
if( !m_script->Load( fname ) )
return false;
m_script->BeginParse();
while( 1 )
{
token = m_script->GetNextToken( true );
if( !token[0] ) break;
if( token[0] != '{' ) continue;
if( m_numMDLEffectClasses >= MAX_SIZE_MDL_WORLD_CLASS )
{
GTH_ERROR( GTH_ERROR_PRINT , "MDL Effect Class overflow.." );
ShowLogInfo("MDL Effect Class overflow..!!!!!!!!!!!!!" );
break;
}
mdlEffectClass = &m_MDLEffectClasses[ m_numMDLEffectClasses++ ];
memset( mdlEffectClass , 0 , sizeof( mdleffectclass_t ) );
mdlEffectClass->inuse = 1;
while( 1 )
{
token = m_script->GetNextToken( true );
if( !token[0] ) break;
if (token[0] == '{')
{
ParseEffectClassState( mdlEffectClass->states );
}
else if (token[0] == '}')
break;
else
ParseEffectClassToken( mdlEffectClass , token );
}
}
return true;
}
int CMDLMng::GetEffectClassStateType( char *token )
{
if ( !stricmp( token , "normal" ) )
return GTH_EFFECT_STATE_NORMAL;
else if( !stricmp( token , "armed" ) )
return GTH_EFFECT_STATE_ARMED;
else if( !stricmp( token , "fired" ) )
return GTH_EFFECT_STATE_FIRED;
else if( !stricmp( token , "hitted" ) )
return GTH_EFFECT_STATE_HITTED;
else if( !stricmp( token , "missed" ) )
return GTH_EFFECT_STATE_MISSED;
return GTH_EFFECT_STATE_NORMAL;
}
float CMDLMng::GetEffectClassAnimTime( char *token )
{
if ( !stricmp( token , "full" ) )
return GTH_EFFECT_ANIMTIME_FULL;
return (float) atof( token );
}
void CMDLMng::ParseEffectClassState( mdleffectclassstate_t *destState )
{
char *token , *param;
mdleffectclassstate_t state;
mdleffectclasspart_t *part;
memset( &state , 0 , sizeof( mdleffectclassstate_t ) );
state.normalSize = 100.0f;
state.soundID = -1;
while( 1 )
{
token = m_script->GetNextToken( true );
if( !token[0] ) break;
if (token[0] == '{')
{
part = &state.parts[ state.numParts++ ];
ParseEffectClassPart( part );
}
else if( !stricmp( token , "height" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
state.bobHeight = (float) atof( param );
}
else if( !stricmp( token , "speed" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
state.bobSpeed = (float) atof( param );
}
else if( !stricmp( token , "state" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
state.state = GetEffectClassStateType( param );
}
else if( !stricmp( token , "total" ) )
{
}
else if( !stricmp( token , "normalsize" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
state.normalSize = (float) atof( param );
}
else if( !stricmp( token , "sound" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
state.soundID = GetGameSampleID( param );
}
else if (token[0] == '}')
{
break;
}
else if ( ! stricmp ( token, "set_ground" ) )
{
param = g_script.GetNextToken ( false );
if ( ! param [0] ) return;
if ( atoi ( param ) == 1 )
{
state.setground = true;
}
else
{
state.setground = false;
}
}
else if ( ! stricmp( token, "projectile" ) )
{
param = g_script.GetNextToken ( false );
if ( ! param [0] ) continue;
if ( atoi ( param ) == 1 )
{
state.projectile = true;
}
else
{
state.projectile = false;
}
}
else if ( ! stricmp( token, "projectile_height" ) )
{
param = g_script.GetNextToken ( false );
if ( ! param[ 0 ] ) continue;
state.projectileHeight = (float)atof ( param );
}
else if ( ! stricmp( token, "start_time" ) )
{
param = g_script.GetNextToken ( false );
if ( ! param[ 0 ] ) continue;
state.startTime = (float)atof ( param );
}
m_script->SkipLine();
}
memcpy( &destState[ state.state ] , &state , sizeof( mdleffectclassstate_t ) );
}
void CMDLMng::ParseEffectClassPart( mdleffectclasspart_t *part )
{
char *token , *param;
part->mdlIdx = -1;
part->msecPerFrame = 100.0f;
part->scale = 1.0f;
part->rotSpeed = 0.0f;
part->startTime = 0.0f;
part->endTime = GTH_EFFECT_ANIMTIME_FULL;
while( 1 )
{
token = m_script->GetNextToken( true );
if( !token[0] ) break;
if( token[0] == '}' )
{
break;
}
else if( !stricmp( token , "model" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
strcpy( part->mdlName , param );
}
else if( !stricmp( token , "scale" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->scale = (float) atof( param );
}
else if( !stricmp( token , "rotate_speed" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->rotSpeed = (float) atof( param );
}
else if( !stricmp( token , "tag" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
strcpy( part->tagName , param );
}
else if( !stricmp( token , "frame_per_second" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->msecPerFrame = (float) atof( param );
if( part->msecPerFrame > 1.0f )
part->msecPerFrame = 1000.0f / part->msecPerFrame;
}
else if( !stricmp( token , "start" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->startTime = GetEffectClassAnimTime( param );
}
else if( !stricmp( token , "end" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->endTime = GetEffectClassAnimTime( param );
}
else if( !stricmp( token , "self_rotate_speed" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->selfRotSpeed = (float) atof( param );
}
else if( !stricmp ( token , "offset" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->offset[0] = (float) atof( param );
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->offset[1] = (float) atof( param );
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->offset[2] = (float) atof( param );
}
else if( !stricmp( token , "req_level" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->req_level = (int) atoi( param );
}
else if( !stricmp( token , "billboard" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
if( ! stricmp( param, "true" ) )
part->billboard = true;
else if( ! stricmp( param, "false" ) )
part->billboard = false;
}
else if( !stricmp ( token , "angle_offset" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->angleOffset[0] = (int) atoi( param );
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->angleOffset[1] = (int) atoi( param );
param = g_script.GetNextToken( false );
if( !param[0] ) continue;
part->angleOffset[2] = (int) atoi( param );
}
m_script->SkipLine();
}
}
void CMDLMng::ParseEffectClassToken( mdleffectclass_t *mdlEffectClass , char *token )
{
char *param;
if( !stricmp( token , "classname" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
mdlEffectClass->classType = GetEffectClassType( param );
}
else if( !stricmp( token , "effectname" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
strcpy( mdlEffectClass->effectName , param );
}
else if( !stricmp( token , "effectid" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
mdlEffectClass->effectID = (int) atoi( param );
}
else if( !stricmp( token , "description" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
strcpy( mdlEffectClass->effectDesc , param );
}
else if( !stricmp( token , "maxlevel" ) )
{
param = g_script.GetNextToken( false );
if( !param[0] ) return;
mdlEffectClass->maxLevel = (int) atoi( param );
}
else if ( ! stricmp( token, "inuse" ) )
{
param = g_script.GetNextToken( false );
if ( ! param[ 0 ] )
return;
mdlEffectClass->inuse = (int)atoi( param );
}
m_script->SkipLine();
}
int CMDLMng::GetEffectClassType( char *token )
{
if ( !stricmp( token , "gth_effect_model" ) )
return GTH_EFFECT_CLASS_MODEL;
else if( !stricmp( token , "gth_effect_multi_model" ) )
return GTH_EFFECT_CLASS_MULTI_MODEL;
else if( !stricmp( token , "gth_effect_pointer" ) )
return GTH_EFFECT_CLASS_POINTER;
return GTH_EFFECT_CLASS_NONE;
}
int CMDLMng::LinkMDLEffectClass( int idxMDLClass )
{
int i , j;
int k;
mdleffectclass_t *mdlEffectClass;
mdleffectclassstate_t *state;
mdleffectclasspart_t *part;
CMDL *mdl;
int flag;
float completeTime , partCompleteTime;
mdlEffectClass = &m_MDLEffectClasses[idxMDLClass];
if( mdlEffectClass->loaded ) return true;
state = &mdlEffectClass->states[0];
for( i = 0 ; i < MAX_SIZE_GTH_EFFECT_CLASS_STATE ; i++ , state++ )
{
if( state->numParts <= 0 ) continue;
flag = true;
partCompleteTime = -999999.0f;
part = &state->parts[0];
for( j = 0 ; j < state->numParts ; j++ , part++ )
{
if( part->tagName[0] )
{
if( !stricmp( part->tagName , "tag_hand" ) )
part->onlyTag = true;
}
part->mdlIdx = LoadMDL( part->mdlName );
if( part->mdlIdx < 0 )
{
flag = false;
break;
}
else
{
if ( part->endTime < 0 )
{
for ( k = part->req_level ; k < MAX_SIZE_EFFECT_LEVEL ; k++ )
{
mdl = GetMDL( part->mdlIdx );
if( mdl == NULL ) continue;
part->numFrames = mdl->m_numBoneFrames;
completeTime = ( mdl->m_numBoneFrames - 1 ) * part->msecPerFrame;
if ( ( completeTime + part->startTime ) > state->completeTime[ k ] )
state->completeTime[ k ] = ( completeTime + part->startTime );
}
}
else
{
for ( k = part->req_level ; k < MAX_SIZE_EFFECT_LEVEL ; k++ )
{
if ( part->endTime > state->completeTime[k] )
state->completeTime[k] = part->endTime;
}
}
}
}
if( flag )
{
CalcEffectBoundBox( state );
}
state->loaded = flag;
}
if( mdlEffectClass->classType != GTH_EFFECT_CLASS_MULTI_MODEL )
{
if( mdlEffectClass->states[ GTH_EFFECT_STATE_NORMAL ].loaded )
mdlEffectClass->loaded = true;
else
mdlEffectClass->loaded = false;
}
else
{
if( mdlEffectClass->states[ GTH_EFFECT_STATE_ARMED ].loaded
&& mdlEffectClass->states[ GTH_EFFECT_STATE_HITTED ].loaded )
mdlEffectClass->loaded = true;
else
mdlEffectClass->loaded = false;
}
if( mdlEffectClass->loaded )
{
if ( mdlEffectClass->classType == GTH_EFFECT_CLASS_POINTER )
{
for ( i = 0 ; i < MAX_SIZE_EFFECT_LEVEL ; i++ )
mdlEffectClass->states[ GTH_EFFECT_STATE_NORMAL ].completeTime[ i ] = -99999.0f;
mdlEffectClass->completeTime = -99999.0f;
}
else if( mdlEffectClass->classType == GTH_EFFECT_CLASS_MODEL )
mdlEffectClass->completeTime = mdlEffectClass->states[ GTH_EFFECT_STATE_NORMAL ].completeTime[ 0 ];
else
mdlEffectClass->completeTime = mdlEffectClass->states[ GTH_EFFECT_STATE_NORMAL ].completeTime[ 0 ];
}
return mdlEffectClass->loaded;
}
void CMDLMng::CalcEffectBoundBox( mdleffectclassstate_t *state )
{
mdleffectclasspart_t *part;
vec3_t stateMins , stateMaxs;
vec3_t partMins , partMaxs;
CMDL *mdl;
int i;
ClearBounds( stateMins , stateMaxs );
part = &state->parts[0];
for( i = 0 ; i < state->numParts ; i++ , part++ )
{
mdl = GetMDL( part->mdlIdx );
if( mdl == NULL ) continue;
VectorCopy( partMins , mdl->m_mins );
VectorCopy( partMaxs , mdl->m_maxs );
if( part->rotSpeed != 0.0f )
{
CalcSphereBoundBox( partMins , partMaxs );
}
VectorScale( partMins , partMins , part->scale );
VectorScale( partMaxs , partMaxs , part->scale );
AddPointToBounds( partMins , stateMins , stateMaxs );
AddPointToBounds( partMaxs , stateMins , stateMaxs );
}
if( state->bobSpeed != 0.0f )
{
stateMins[2] -= state->bobHeight;
stateMaxs[2] += state->bobHeight;
}
VectorCopy( state->mins , stateMins );
VectorCopy( state->maxs , stateMaxs );
}
int CMDLMng::InitEffectClass()
{
for( int i = 0 ; i < m_numMDLEffectClasses ; i++ )
{
if ( ! m_MDLEffectClasses[ i ].inuse )
continue;
LinkMDLEffectClass( i );
}
memset( m_linkedMDLEffectEntities , 0 , sizeof( mdleffectentitylink_t ) * MAX_SIZE_MDL_EFFECT_CLASS );
memset( m_MDLEffectEntities , 0 , sizeof( mdleffectentity_t ) * MAX_SIZE_MDL_EFFECT_ENTITY );
return true;
}
void CMDLMng::ClearEffectUseFlag()
{
memset( m_linkedMDLEffectEntities , 0 , sizeof( mdleffectentitylink_t ) * m_numMDLEffectClasses );
m_currMDLEffectEntity = 0;
}
int CMDLMng::AddEffectEntity ( int entityIndex,
GTH_EFFECT_CLASS_TYPE classType,
int effectID,
vec3_t origin,
vec3_t target,
vec3_t angles,
float hitDiff,
int effect_level,
int follow_attacker,
int attackerIdx,
int attackerType,
int defenderIdx,
int defenderType,
float offset_x,
float offset_y,
float offset_z,
float in_lifeTime,
int in_follow_repetition )
{
mdleffectclass_t *mdlEffectClass;
mdleffectentity_t *mdlEntity;
mdleffectentitylink_t *linkedMDLEntity;
int i;
int idxClass;
mdlEffectClass = &m_MDLEffectClasses[0];
for( i = 0 ; i < m_numMDLEffectClasses ; i++ , mdlEffectClass++ )
{
if( mdlEffectClass->classType == GTH_EFFECT_CLASS_NONE ) continue;
if( mdlEffectClass->classType == classType && mdlEffectClass->effectID == effectID )
{
idxClass = i;
break;
}
}
if( i == m_numMDLEffectClasses )
return -1;
if( !mdlEffectClass->loaded )
return -1;
chASSERT( m_MDLEffectClasses[ idxClass ].inuse );
if ( ! m_MDLEffectClasses[ idxClass ].inuse )
{
return -1;
}
m_currMDLEffectEntity = entityIndex;
mdlEntity = &m_MDLEffectEntities[ m_currMDLEffectEntity ];
memset ( mdlEntity, 0, sizeof (mdleffectentity_t) );
linkedMDLEntity = &m_linkedMDLEffectEntities[ idxClass ];
mdlEntity->idxClass = idxClass;
mdlEntity ->idxEntity = m_currMDLEffectEntity;
mdlEntity->next = linkedMDLEntity->linked;
mdlEntity->prev = NULL;
if( linkedMDLEntity->linked )
linkedMDLEntity->linked->prev = mdlEntity;
linkedMDLEntity->linked = mdlEntity;
VectorCopy( mdlEntity->origin , origin );
SetEffectTarget( mdlEntity , target , angles );
mdlEntity->angles[ YAW ] += 90.0f;
mdlEntity->state = GTH_EFFECT_STATE_NORMAL;
mdlEntity->visible = false;
mdlEntity->firedStep = 0;
mdlEntity->hitDiff = hitDiff;
mdlEntity->m_SendAttackMessage=false;
mdlEntity->effectID = effectID;
if ( follow_attacker && ! in_follow_repetition )
mdlEntity ->follow_attacker = -follow_attacker;
else
mdlEntity ->follow_attacker = follow_attacker;
mdlEntity ->attackerIdx = attackerIdx;
mdlEntity ->defenderIdx = defenderIdx;
mdlEntity ->attackerType = attackerType;
mdlEntity ->defenderType = defenderType;
mdlEntity->lifeTime = in_lifeTime;
mdlEntity ->offset [0] = offset_x;
mdlEntity ->offset [1] = offset_y;
mdlEntity ->offset [2] = offset_z;
mdlEntity ->velocity = MDL_PROJECTILE_INITIAL_VELOCITY;
mdlEntity->startTime = m_currMilliTime;
mdlEntity->effect_level = effect_level;
mdlEntity->completeTime = GetEffectStateCompleteTime( idxClass , GTH_EFFECT_STATE_NORMAL , m_currMilliTime , mdlEntity->effect_level );
if( m_MDLEffectClasses[ idxClass ].states[ GTH_EFFECT_STATE_NORMAL ].soundID >= 0 )
m_musicMng->PlaySample3D( m_MDLEffectClasses[ idxClass ].states[ GTH_EFFECT_STATE_NORMAL ].soundID
, GTH_SOUND_PLAY_ONCE , origin );
return m_currMDLEffectEntity;
}
void CMDLMng::SetEffectTarget( mdleffectentity_t *mdlEntity , vec3_t target , vec3_t angles )
{
vec3_t diff;
if( !target )
{
if( angles )
VectorCopy( mdlEntity->angles , angles );
else
VectorClear( mdlEntity->angles );
mdlEntity->firedScale = 0.0f;
return;
}
VectorCopy( mdlEntity->target , target );
VectorSubtract( diff , target , mdlEntity->origin );
VectorToAngles( diff , mdlEntity->angles );
}
int CMDLMng::DeleteEffectEntity ( int idxMDLEntity )
{
mdleffectentity_t *mdlEntity;
mdlEntity = &m_MDLEffectEntities [idxMDLEntity];
if ( mdlEntity ->prev )
{
mdlEntity ->prev ->next = mdlEntity ->next;
}
else
{
m_linkedMDLEffectEntities [mdlEntity ->idxClass].linked = mdlEntity ->next;
}
if ( mdlEntity ->next )
mdlEntity ->next ->prev = mdlEntity ->prev;
mdlEntity ->next = NULL;
mdlEntity ->prev = NULL;
return true;
}
void CMDLMng::SetMDLEffectEntityOrigin( int idxMDLEntity , vec3_t origin )
{
VectorCopy( m_MDLEffectEntities[ idxMDLEntity ].origin , origin );
}
void CMDLMng::SetMDLEffectEntityAngles( int idxMDLEntity , vec3_t angles )
{
VectorCopy( m_MDLEffectEntities[ idxMDLEntity ].angles , angles );
}
mdleffectentity_t *CMDLMng::GetMDLEffectEntity( int idxMDLEntity )
{
return &m_MDLEffectEntities[ idxMDLEntity ];
}
mdleffectentitylink_t *CMDLMng::GetLinkedMDLEffectEntity( int idxClass )
{
return &m_linkedMDLEffectEntities[ idxClass ];
}
int CMDLMng::GetMDLEffectClassBoundBox( int idxMDLEntity , int state , vec3_t mins , vec3_t maxs )
{
mdleffectentity_t *mdlEntity;
mdlEntity = &m_MDLEffectEntities[ idxMDLEntity ];
if( m_MDLEffectClasses[ mdlEntity->idxClass ].states[ state ].loaded )
{
VectorCopy( mins , m_MDLEffectClasses[ mdlEntity->idxClass ].states[ state ].mins );
VectorCopy( maxs , m_MDLEffectClasses[ mdlEntity->idxClass ].states[ state ].maxs );
}
else
{
VectorClear( mins );
VectorClear( maxs );
}
return true;
}
float CMDLMng::GetEffectStateCompleteTime( int idxClass , int state , float startTime,
int effect_level )
{
if( m_MDLEffectClasses[ idxClass ].completeTime > 0.0f )
return m_MDLEffectClasses[ idxClass ].states[ state ].completeTime[ effect_level ] + startTime;
else
return m_MDLEffectClasses[ idxClass ].states[ state ].completeTime[ effect_level ];
}
int CMDLMng::IsOverEffectCompleteTime( int idxMDLEntity )
{
mdleffectentity_t *mdlEntity;
mdlEntity = &m_MDLEffectEntities[ idxMDLEntity ];
mdlEntity->animTime = m_currTime;
if( mdlEntity->completeTime < 0.0f )
return GTH_EFFECT_NOT_COMPLETED;
if ( mdlEntity ->follow_attacker > 0 )
return GTH_EFFECT_NOT_COMPLETED;
if( mdlEntity->completeTime > m_currMilliTime )
return GTH_EFFECT_NOT_COMPLETED;
if( m_MDLEffectClasses[ mdlEntity->idxClass ].classType == GTH_EFFECT_CLASS_MODEL )
return GTH_EFFECT_ALL_STATE_COMPLETED;
else if( m_MDLEffectClasses[ mdlEntity->idxClass ].classType == GTH_EFFECT_CLASS_POINTER )
return GTH_EFFECT_ALL_STATE_COMPLETED;
else
{
if ( mdlEntity->state == GTH_EFFECT_STATE_ARMED )
return GTH_EFFECT_ARMED_STATE_COMPLETED;
else if( mdlEntity->state == GTH_EFFECT_STATE_FIRED )
{
if( mdlEntity->firedStep < GTH_EFFECT_FIRED_STEP_COMPLETE )
return GTH_EFFECT_ARMED_STATE_COMPLETED;
else
return GTH_EFFECT_FIRED_STATE_COMPLETED;
}
else if( mdlEntity->state == GTH_EFFECT_STATE_HITTED )
{
if( mdlEntity->firedStep < GTH_EFFECT_HIT_STEP_COMPLETE )
return GTH_EFFECT_FIRED_STATE_COMPLETED;
else
return GTH_EFFECT_ALL_STATE_COMPLETED;
}
else if( mdlEntity->state == GTH_EFFECT_STATE_MISSED )
{
if( mdlEntity->firedStep < GTH_EFFECT_HIT_STEP_COMPLETE )
return GTH_EFFECT_FIRED_STATE_COMPLETED;
else
return GTH_EFFECT_ALL_STATE_COMPLETED;
}
}
return GTH_EFFECT_ALL_STATE_COMPLETED;
}
int CMDLMng::SetFiredState( int idxMDLEntity , vec3_t target , vec3_t mins , vec3_t maxs )
{
mdleffectentity_t *mdlEntity;
vec3_t diff;
float dist;
mdlEntity = &m_MDLEffectEntities[ idxMDLEntity ];
if( !target ) return false;
VectorSubtract( diff , target , mdlEntity->origin );
VectorNormalize( diff );
VectorScale( diff , diff , mdlEntity->hitDiff );
VectorAdd( target , target , diff );
VectorSubtract( diff , target , mdlEntity->origin );
dist = (float) sqrt( VectorDotProduct( diff , diff ) );
VectorToAngles( diff , mdlEntity->angles );
mdlEntity->angles[ YAW ] += 90.0f;
mdlEntity->firedScale = dist / m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_FIRED ].normalSize;
VectorCopy( mdlEntity->target , target );
if( mdlEntity->state == GTH_EFFECT_STATE_ARMED )
{
mdlEntity->state = GTH_EFFECT_STATE_FIRED;
mdlEntity->firedStep = 1;
mdlEntity->startTime = mdlEntity->completeTime;
mdlEntity->completeTime = mdlEntity->startTime
+ ( GTH_EFFECT_FIRED_STEP_DIVINE * mdlEntity->firedStep
* GetEffectStateCompleteTime( mdlEntity->idxClass , GTH_EFFECT_STATE_FIRED , 0 , mdlEntity->effect_level ) );
if( m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_FIRED ].soundID >= 0 )
m_musicMng->PlaySample3D( m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_FIRED ].soundID
, GTH_SOUND_PLAY_ONCE , mdlEntity->origin );
}
else
{
mdlEntity->firedStep++;
mdlEntity->completeTime = mdlEntity->startTime
+ ( GTH_EFFECT_FIRED_STEP_DIVINE * mdlEntity->firedStep
* GetEffectStateCompleteTime( mdlEntity->idxClass , GTH_EFFECT_STATE_FIRED , 0 , mdlEntity->effect_level ) );
}
VectorCopy( mins , m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_FIRED ].mins );
VectorCopy( maxs , m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_FIRED ].maxs );
mins[1] *= mdlEntity->firedScale;
maxs[1] *= mdlEntity->firedScale;
return true;
}
int CMDLMng::SetHittedState( int idxMDLEntity , vec3_t target , vec3_t mins , vec3_t maxs )
{
mdleffectentity_t *mdlEntity;
vec3_t diff;
mdlEntity = &m_MDLEffectEntities[ idxMDLEntity ];
if( !target ) return false;
VectorSubtract( diff , target , mdlEntity->origin );
VectorNormalize( diff );
VectorScale( diff , diff , mdlEntity->hitDiff );
VectorAdd( target , target , diff );
if ( VectorCompare ( target , mdlEntity->origin ) )
VectorCopy( diff , target );
else
VectorSubtract( diff , target , mdlEntity->origin );
VectorToAngles( diff , mdlEntity->angles );
mdlEntity->angles[ YAW ] += 90.0f;
VectorCopy( mdlEntity->target , target );
if( mdlEntity->state == GTH_EFFECT_STATE_FIRED )
{
mdlEntity->state = GTH_EFFECT_STATE_HITTED;
mdlEntity->firedStep = 1;
mdlEntity->startTime = mdlEntity->completeTime;
mdlEntity->completeTime = mdlEntity->startTime
+ ( GTH_EFFECT_HIT_STEP_DIVINE * mdlEntity->firedStep
* GetEffectStateCompleteTime( mdlEntity->idxClass , GTH_EFFECT_STATE_HITTED , 0 , mdlEntity->effect_level ) );
if( m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_HITTED ].soundID >= 0 )
m_musicMng->PlaySample3D( m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_HITTED ].soundID
, GTH_SOUND_PLAY_ONCE , mdlEntity->target );
}
else
{
mdlEntity->firedStep++;
mdlEntity->completeTime = mdlEntity->startTime
+ ( GTH_EFFECT_HIT_STEP_DIVINE * mdlEntity->firedStep
* GetEffectStateCompleteTime( mdlEntity->idxClass , GTH_EFFECT_STATE_HITTED , 0 , mdlEntity->effect_level ) );
}
VectorCopy( mdlEntity->origin , mdlEntity->target );
VectorCopy( mins , m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_HITTED ].mins );
VectorCopy( maxs , m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_HITTED ].maxs );
return true;
}
int CMDLMng::SetMissedState( int idxMDLEntity , vec3_t target , vec3_t mins , vec3_t maxs )
{
mdleffectentity_t *mdlEntity;
vec3_t diff;
mdlEntity = &m_MDLEffectEntities[ idxMDLEntity ];
if( !m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_MISSED ].loaded )
return false;
if( !target ) return false;
VectorSubtract( diff , target , mdlEntity->origin );
VectorNormalize( diff );
VectorScale( diff , diff , mdlEntity->hitDiff );
VectorAdd( target , target , diff );
if ( VectorCompare ( target , mdlEntity->origin ) )
VectorCopy( diff , target );
else
VectorSubtract( diff , target , mdlEntity->origin );
VectorToAngles( diff , mdlEntity->angles );
mdlEntity->angles[ YAW ] += 90.0f;
VectorCopy( mdlEntity->target , target );
if( mdlEntity->state == GTH_EFFECT_STATE_FIRED )
{
mdlEntity->state = GTH_EFFECT_STATE_MISSED;
mdlEntity->firedStep = 1;
mdlEntity->startTime = mdlEntity->completeTime;
mdlEntity->completeTime = mdlEntity->startTime
+ ( GTH_EFFECT_HIT_STEP_DIVINE * mdlEntity->firedStep
* GetEffectStateCompleteTime( mdlEntity->idxClass , GTH_EFFECT_STATE_MISSED , 0 , mdlEntity->effect_level ) );
if( m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_MISSED ].soundID >= 0 )
m_musicMng->PlaySample3D( m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_MISSED ].soundID
, GTH_SOUND_PLAY_ONCE , mdlEntity->target );
}
else
{
mdlEntity->firedStep++;
mdlEntity->completeTime = mdlEntity->startTime
+ ( GTH_EFFECT_HIT_STEP_DIVINE * mdlEntity->firedStep
* GetEffectStateCompleteTime( mdlEntity->idxClass , GTH_EFFECT_STATE_HITTED , 0 , mdlEntity->effect_level ) );
}
VectorCopy( mdlEntity->origin , mdlEntity->target );
VectorCopy( mins , m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_MISSED ].mins );
VectorCopy( maxs , m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_MISSED ].maxs );
return true;
}
int CMDLMng::IsOverEffectCompleteTime_Neo ( int idxMDLEntity,
bool &processDamage,
bool &sendAttackMessage )
{
mdleffectentity_t *mdlEntity;
mdleffectclass_t *effectclass;
mdlEntity = &m_MDLEffectEntities[ idxMDLEntity ];
effectclass = &m_MDLEffectClasses[ mdlEntity->idxClass ];
mdlEntity->animTime = m_currTime;
if ( mdlEntity->lifeTime > 0.0f )
{
float elapsedTime = m_currMilliTime - mdlEntity->startTime;
if ( elapsedTime > mdlEntity->lifeTime )
{
return GTH_EFFECT_ALL_STATE_COMPLETED;
}
}
if( mdlEntity->completeTime < 0.0f )
return GTH_EFFECT_NOT_COMPLETED;
if ( mdlEntity ->follow_attacker > 0 )
return GTH_EFFECT_NOT_COMPLETED;
if ( effectclass->states[ GTH_EFFECT_STATE_FIRED ].startTime < 0 )
{
if ( mdlEntity->state == GTH_EFFECT_STATE_ARMED )
{
if ( ( mdlEntity->completeTime + effectclass->states[ GTH_EFFECT_STATE_FIRED ].startTime ) > m_currMilliTime )
return GTH_EFFECT_NOT_COMPLETED;
mdlEntity->backup_startTime = mdlEntity->startTime;
VectorCopy( mdlEntity->backup_origin, mdlEntity->origin );
VectorCopy( mdlEntity->backup_angles, mdlEntity->angles );
}
}
else if ( effectclass->states[ GTH_EFFECT_STATE_HITTED ].startTime < 0 )
{
if ( ( effectclass->states[ GTH_EFFECT_STATE_FIRED ].numParts <= 0 ) &&
( mdlEntity->state == GTH_EFFECT_STATE_ARMED ) )
{
if ( ( mdlEntity->completeTime + effectclass->states[ GTH_EFFECT_STATE_HITTED ].startTime ) > m_currMilliTime )
return GTH_EFFECT_NOT_COMPLETED;
mdlEntity->backup_startTime = mdlEntity->startTime;
VectorCopy( mdlEntity->backup_origin, mdlEntity->origin );
VectorCopy( mdlEntity->backup_angles, mdlEntity->angles );
}
}
else if ( mdlEntity->completeTime > m_currMilliTime )
{
return GTH_EFFECT_NOT_COMPLETED;
}
if( m_MDLEffectClasses[ mdlEntity->idxClass ].classType == GTH_EFFECT_CLASS_MODEL )
return GTH_EFFECT_ALL_STATE_COMPLETED;
else if( m_MDLEffectClasses[ mdlEntity->idxClass ].classType == GTH_EFFECT_CLASS_POINTER )
return GTH_EFFECT_ALL_STATE_COMPLETED;
else
{
switch ( mdlEntity->state )
{
case GTH_EFFECT_STATE_ARMED:
{
if ( effectclass->states[ GTH_EFFECT_STATE_FIRED ].projectile )
mdlEntity->origin[ 2 ] += effectclass->states[ GTH_EFFECT_STATE_FIRED ].projectileHeight;
return GTH_EFFECT_ARMED_STATE_COMPLETED;
}
break;
case GTH_EFFECT_STATE_FIRED:
{
vec3_t diff;
VectorSubtract ( diff, mdlEntity->target, mdlEntity->origin );
float length = VectorLength( diff );
if (mdlEntity->m_SendAttackMessage && length < MDL_PROJECTILE_HIT_MARGIN )
{
processDamage = true;
return GTH_EFFECT_FIRED_STATE_COMPLETED;
}
else if ( length < MDL_PROJECTILE_SEND_ATTACK_MARGIN )
{
sendAttackMessage = true;
mdlEntity->m_SendAttackMessage = true;
return GTH_EFFECT_ARMED_STATE_COMPLETED;
}
else
return GTH_EFFECT_ARMED_STATE_COMPLETED;
}
break;
case GTH_EFFECT_STATE_HITTED:
{
if( mdlEntity->firedStep < GTH_EFFECT_HIT_STEP_COMPLETE )
return GTH_EFFECT_FIRED_STATE_COMPLETED;
else
return GTH_EFFECT_ALL_STATE_COMPLETED;
}
break;
case GTH_EFFECT_STATE_MISSED:
{
if( mdlEntity->firedStep < GTH_EFFECT_HIT_STEP_COMPLETE )
return GTH_EFFECT_FIRED_STATE_COMPLETED;
else
return GTH_EFFECT_ALL_STATE_COMPLETED;
}
break;
}
}
return GTH_EFFECT_ALL_STATE_COMPLETED;
}
int CMDLMng::SetFiredState_Neo ( int idxMDLEntity,
vec3_t target,
vec3_t mins,
vec3_t maxs )
{
mdleffectentity_t *mdlEntity;
vec3_t diff;
Fx_CHARACTER_t *character;
mdlEntity = &m_MDLEffectEntities [idxMDLEntity];
if ( ! target )
return false;
VectorSubtract ( diff, target, mdlEntity->origin );
VectorNormalize ( diff );
target [0] = target [0] + ( diff [0] * mdlEntity->hitDiff );
target [1] = target [1] + ( diff [1] * mdlEntity->hitDiff );
target [2] = target [2] + ( diff [2] * mdlEntity->hitDiff );
float scaleFactor;
character = g_charManager ->FindCharacterByServerIndex (mdlEntity ->attackerIdx, mdlEntity ->attackerType);
if ( character == NULL )
return false;
scaleFactor = character->stat_attackSpeed * 0.001f
* ( mdlEntity ->velocity * g_timer.GetElapsedTime () + 0.5f * MDL_PROJECTILE_ACCELERATION * g_timer.GetElapsedTime () * g_timer.GetElapsedTime () );
mdlEntity ->velocity = mdlEntity ->velocity + MDL_PROJECTILE_ACCELERATION * g_timer.GetElapsedTime ();
mdlEntity->origin [0] = mdlEntity->origin [0] + ( diff [0] * scaleFactor );
mdlEntity->origin [1] = mdlEntity->origin [1] + ( diff [1] * scaleFactor );
mdlEntity->origin [2] = mdlEntity->origin [2] + ( diff [2] * scaleFactor );
vec3_t check;
VectorSubtract ( check, target, mdlEntity->origin );
VectorNormalize ( check );
float ACCEPTRANGE = 0.999f;
if ( VectorDotProduct ( check, diff ) < ACCEPTRANGE )
{
VectorCopy ( mdlEntity->origin, target );
}
VectorToAngles ( diff, mdlEntity->angles );
mdlEntity->angles [YAW] += 90.0f;
VectorCopy ( mdlEntity->target, target );
if ( mdlEntity->state == GTH_EFFECT_STATE_ARMED )
{
mdlEntity->state = GTH_EFFECT_STATE_FIRED;
mdlEntity->startTime = m_currMilliTime;
if ( m_MDLEffectClasses [mdlEntity->idxClass].states [GTH_EFFECT_STATE_FIRED].soundID >= 0 )
m_musicMng->PlaySample3D ( m_MDLEffectClasses [mdlEntity->idxClass].states [GTH_EFFECT_STATE_FIRED].soundID, GTH_SOUND_PLAY_ONCE, mdlEntity->origin );
}
VectorCopy ( mins, m_MDLEffectClasses [mdlEntity->idxClass].states [GTH_EFFECT_STATE_FIRED].mins );
VectorCopy ( maxs, m_MDLEffectClasses [mdlEntity->idxClass].states [GTH_EFFECT_STATE_FIRED].maxs );
return true;
}
int CMDLMng::SetHittedState_Neo( int idxMDLEntity , vec3_t target , vec3_t mins , vec3_t maxs )
{
mdleffectentity_t *mdlEntity;
vec3_t diff;
Fx_CHARACTER_t *character;
mdlEntity = &m_MDLEffectEntities[ idxMDLEntity ];
if( !target ) return false;
VectorSubtract( diff , target , mdlEntity->origin );
VectorNormalize( diff );
VectorScale( diff , diff , mdlEntity->hitDiff );
VectorAdd( target , target , diff );
if ( VectorCompare ( target , mdlEntity->origin ) )
VectorCopy( diff , target );
else
{
vec3_t char_pos;
character = g_charManager ->FindCharacterByServerIndex ( mdlEntity ->attackerIdx, mdlEntity ->attackerType );
if ( character != NULL )
{
VectorCopy ( char_pos, character->position );
char_pos [2] = target [2];
VectorSubtract( diff , target , char_pos );
}
else
{
return false;
}
}
VectorToAngles( diff , mdlEntity->angles );
mdlEntity->angles[ YAW ] += 90.0f;
VectorCopy( mdlEntity->target , target );
if( mdlEntity->state == GTH_EFFECT_STATE_FIRED )
{
mdlEntity->state = GTH_EFFECT_STATE_HITTED;
mdlEntity->firedStep = 1;
mdlEntity->startTime = m_currMilliTime;
mdlEntity->completeTime = mdlEntity->startTime
+ ( GTH_EFFECT_HIT_STEP_DIVINE * mdlEntity->firedStep
* GetEffectStateCompleteTime( mdlEntity->idxClass , GTH_EFFECT_STATE_HITTED , 0 , mdlEntity->effect_level ) );
if( m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_HITTED ].soundID >= 0 )
m_musicMng->PlaySample3D( m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_HITTED ].soundID
, GTH_SOUND_PLAY_ONCE , mdlEntity->target );
}
else
{
mdlEntity->firedStep++;
mdlEntity->completeTime = mdlEntity->startTime
+ ( GTH_EFFECT_HIT_STEP_DIVINE * mdlEntity->firedStep
* GetEffectStateCompleteTime( mdlEntity->idxClass , GTH_EFFECT_STATE_HITTED , 0 , mdlEntity->effect_level ) );
}
VectorCopy( mdlEntity->origin , mdlEntity->target );
VectorCopy( mins , m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_HITTED ].mins );
VectorCopy( maxs , m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_HITTED ].maxs );
return true;
}
int CMDLMng::SetMissedState_Neo( int idxMDLEntity , vec3_t target , vec3_t mins , vec3_t maxs )
{
mdleffectentity_t *mdlEntity;
vec3_t diff;
mdlEntity = &m_MDLEffectEntities[ idxMDLEntity ];
if( !m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_MISSED ].loaded )
return false;
if( !target ) return false;
VectorSubtract( diff , target , mdlEntity->origin );
VectorNormalize( diff );
VectorScale( diff , diff , mdlEntity->hitDiff );
VectorAdd( target , target , diff );
if ( VectorCompare ( target , mdlEntity->origin ) )
VectorCopy( diff , target );
else
VectorSubtract( diff , target , mdlEntity->origin );
if(mdlEntity->effectID == 6 || mdlEntity->effectID == 31)
{
Fx_CHARACTER_t *character = g_charManager ->FindCharacterByServerIndex (mdlEntity ->attackerIdx, mdlEntity ->attackerType);
if ( character != NULL )
{
VectorToAngles( diff , character->angles );
}
else
{
VectorToAngles( diff , mdlEntity->angles );
}
}
else
{
VectorToAngles( diff , mdlEntity->angles );
mdlEntity->angles[ YAW ] += 90.0f;
}
VectorCopy( mdlEntity->target , target );
if( mdlEntity->state == GTH_EFFECT_STATE_FIRED )
{
mdlEntity->state = GTH_EFFECT_STATE_MISSED;
mdlEntity->firedStep = 1;
mdlEntity->startTime = m_currMilliTime;
mdlEntity->completeTime = mdlEntity->startTime
+ ( GTH_EFFECT_HIT_STEP_DIVINE * mdlEntity->firedStep
* GetEffectStateCompleteTime( mdlEntity->idxClass , GTH_EFFECT_STATE_MISSED , 0 , mdlEntity->effect_level ) );
if( m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_MISSED ].soundID >= 0 )
m_musicMng->PlaySample3D( m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_MISSED ].soundID
, GTH_SOUND_PLAY_ONCE , mdlEntity->target );
}
else
{
mdlEntity->firedStep++;
mdlEntity->completeTime = mdlEntity->startTime
+ ( GTH_EFFECT_HIT_STEP_DIVINE * mdlEntity->firedStep
* GetEffectStateCompleteTime( mdlEntity->idxClass , GTH_EFFECT_STATE_HITTED , 0 , mdlEntity->effect_level ) );
}
VectorCopy( mdlEntity->origin , mdlEntity->target );
VectorCopy( mins , m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_MISSED ].mins );
VectorCopy( maxs , m_MDLEffectClasses[ mdlEntity->idxClass ].states[ GTH_EFFECT_STATE_MISSED ].maxs );
return true;
}
mdleffectentity_t* CMDLMng::DeleteEffectManagerEntity ( mdleffectentity_t *in_entity )
{
mdleffectentity_t *temp;
temp = in_entity ->next;
g_effectMng ->Delete ( in_entity ->idxEntity );
return temp;
}
| C++ |
#include "../global_def.h"
CMDLMng::CMDLMng()
{
m_numMDLs = 0;
m_frameFlag = 0;
m_numMDLWorldClasses = 0;
m_numMDLItemClasses = 0;
m_numMDLEffectClasses = 0;
m_currMDLWorldEntity = 0;
m_currMDLItemEntity = 0;
m_currMDLEffectEntity = 0;
m_format = GTH_MODEL_FORMAT;
m_pD3DDevice = NULL;
m_numBank = 0;
m_numStaticElems = 0;
m_prevNumStaticVerts = 0;
m_currNumStaticVerts = 0;
MEMORYSTATUS memStatus;
GlobalMemoryStatus( &memStatus );
if( memStatus.dwTotalPhys < 535740416 )
{
m_mdlRscSize = 31457280;
}
else
{
m_mdlRscSize = 31457280 * 2;
}
m_resManager.Create( m_mdlRscSize );
m_dynamicVB = NULL;
m_dynamicIB = NULL;
m_staticEB = NULL;
m_currTime = 0.0f;
m_currMilliTime = 0.0f;
m_useFocusItem = true;
m_useFocusWorld = true;
m_focusedItemColor = MAKE_COLOR_ARGB( 0x40 , 0xFF , 0xFF , 0x00 );
}
CMDLMng::~CMDLMng()
{
int i;
int j;
GTH_SAFE_DELETE( m_dynamicVB );
GTH_SAFE_DELETE( m_dynamicIB );
GTH_SAFE_DELETE( m_staticEB );
for( i = 0 ; i < m_numBank ; i++ )
GTH_SAFE_DELETE( m_staticVB[i] );
mdlworldentity_t *entity = &m_MDLWorldEntities[0];
for( i = 0; i < m_currMDLWorldEntity; i++, entity++ )
{
for( j = 0; j < WORLD_ENTITY_MAX_PARTS; j++ )
if( entity->num_cvertex[j] > 0 )
{
GTH_SAFE_DELETE_ARRAY ( entity->collisionVertex[j] );
}
entity->collisionVertex[j] = NULL;
}
}
void CMDLMng::Release()
{
int i;
for( i = 0 ; i < m_numMDLs ; i++ )
m_MDLs[i].Release();
m_dynamicVB->Release();
m_dynamicIB->Release();
if( m_staticEB )
m_staticEB->Release();
for( i = 0 ; i < m_numBank ; i++ )
m_staticVB[i]->Release();
m_shaderMng->Release();
m_texMng->Release( OWNER_TYPE_MODEL );
m_resManager.Create( m_mdlRscSize );
}
CMDL* CMDLMng::GetMDL( int mdlIdx )
{
bool bIsDisposed = m_MDLs[mdlIdx].IsDisposed();
if( m_resManager.GetResource( (RHANDLE)&m_MDLs[mdlIdx] ) == NULL )
{
return NULL;
}
if( bIsDisposed )
{
PrepareMDLShader( mdlIdx );
RestoreVertexInfo( mdlIdx );
}
return( &m_MDLs[mdlIdx] );
}
int CMDLMng::PrepareMDLShader( int mdlIdx )
{
int idxShader;
shader_t *shader;
mdlshaderref_t *shaderRef;
int numShaderRefs;
CMDL *mdl = &m_MDLs[mdlIdx];
mdl->m_needDynVB = false;
numShaderRefs = mdl->GetShaderRef( &shaderRef );
for( int i = 0 ; i < numShaderRefs ; i++ )
{
idxShader = m_shaderMng->SearchShader( shaderRef[i].name );
if( idxShader < 0 )
{
shaderRef[i].shader = m_texMng->Add( shaderRef[i].name , OWNER_TYPE_MODEL );
shaderRef[i].surfaceFlags = 0;
shaderRef[i].isShader = false;
continue;
}
m_shaderMng->InitShader( idxShader );
shader = m_shaderMng->GetShader( idxShader );
shaderRef[i].shader = idxShader;
shaderRef[i].surfaceFlags = shader->flags;
shaderRef[i].isShader = true;
if( shader->flags & SHADER_TCGEN )
{
mdl->m_needDynVB = true;
}
}
for( i = 0 ; i < mdl->m_numMeshes ; i++ )
{
mdl->m_meshes[i].needTCGen = false;
mdl->m_meshes[i].offsetTCGenVB = 0;
mdl->m_meshes[i].offsetTCGenEB = 0;
if( shaderRef[ mdl->m_meshes[i].skinInfo ].surfaceFlags & SHADER_TCGEN )
mdl->m_meshes[i].needTCGen = true;
}
return true;
}
int CMDLMng::PrepareMDLShader()
{
return true;
for( int i = 0; i < m_numMDLs; i ++ )
{
if( m_MDLs[i].IsDisposed() ) continue;
PrepareMDLShader( i );
}
return true;
}
int CMDLMng::Initialize()
{
m_currTime = 0.0f;
m_currMilliTime = 0.0f;
InitItemClass();
InitEffectClass();
EndOfCalcVertexBuffer();
if( !GenDynamicMem() )
return false;
return true;
}
int CMDLMng::Restore( LPDIRECT3DDEVICE8 pD3DDevice )
{
m_pD3DDevice = pD3DDevice;
for( int i = 0 ; i < m_numBank ; i++ )
{
if( m_bankSize[i] <= 0 ) continue;
m_staticVB[i]->Create( m_bankSize[ i ] , m_format , GTH_VERTEX_BUFFER | GTH_STATIC_BUFFER | GTH_WRITEONLY );
}
m_dynamicVB->Create( MAX_SIZE_MDL_DYNAMIC_VERTEX_BUFFER , m_format
, GTH_VERTEX_BUFFER | GTH_DYNAMIC_BUFFER | GTH_WRITEONLY);
m_dynamicIB->Create( MAX_SIZE_MDL_DYNAMIC_INDEX_BUFFER , GTH_FORMAT_INDEX16
, GTH_INDEX_BUFFER | GTH_DYNAMIC_BUFFER | GTH_WRITEONLY );
if( m_numStaticElems > 0 )
{
m_staticEB->Create( m_numStaticElems , GTH_FORMAT_INDEX16
, GTH_INDEX_BUFFER | GTH_STATIC_BUFFER | GTH_WRITEONLY );
}
return UploadVertexBuffer();
}
int CMDLMng::GenDynamicMem()
{
int i;
for( i = 0 ; i < m_numBank ; i++ )
{
if( m_bankSize[i] <= 0 )
{
m_staticVB[i] = NULL;
continue;
}
m_staticVB[i] = new CD3DBuffer();
if( !m_staticVB[i] )
{
GTH_ERROR( GTH_ERROR_NOT_ENOUGH_MEMORY , "CMDLMng::GenDynamicMem::m_staticVB" );
return false;
}
m_staticVB[i]->Create( m_bankSize[ i ] , m_format , GTH_VERTEX_BUFFER | GTH_STATIC_BUFFER | GTH_WRITEONLY );
}
m_dynamicVB = new CD3DBuffer();
if( !m_dynamicVB )
{
GTH_ERROR( GTH_ERROR_NOT_ENOUGH_MEMORY , "CMDLMng::GenDynamicMem::m_dynamicVB" );
return false;
}
m_dynamicVB->Create( MAX_SIZE_MDL_DYNAMIC_VERTEX_BUFFER , m_format
, GTH_VERTEX_BUFFER | GTH_DYNAMIC_BUFFER | GTH_WRITEONLY);
m_dynamicIB = new CD3DBuffer();
if( !m_dynamicIB )
{
GTH_ERROR( GTH_ERROR_NOT_ENOUGH_MEMORY , "CMDLMng::GenDynamicMem::m_dynamicIB" );
return false;
}
m_dynamicIB->Create( MAX_SIZE_MDL_DYNAMIC_INDEX_BUFFER , GTH_FORMAT_INDEX16
, GTH_INDEX_BUFFER | GTH_DYNAMIC_BUFFER | GTH_WRITEONLY );
if( m_numStaticElems > 0 )
{
m_staticEB = new CD3DBuffer();
if( !m_staticEB )
{
GTH_ERROR( GTH_ERROR_NOT_ENOUGH_MEMORY , "CMDLMng::GenDynamicMem::m_staticEB" );
return false;
}
m_staticEB->Create( m_numStaticElems , GTH_FORMAT_INDEX16
, GTH_INDEX_BUFFER | GTH_STATIC_BUFFER | GTH_WRITEONLY );
}
else
m_staticEB = NULL;
return true;
}
void CMDLMng::CalcVertexBuffer( CMDL *mdl )
{
int i;
mdlmesh_t *mesh;
if( mdl->m_numBoneFrames > 1 || mdl->m_needDynVB ) return;
mesh = &mdl->m_meshes[0];
for( i = 0; i < mdl->m_numMeshes; i++ , mesh++ )
{
m_currNumStaticVerts += mesh->vertexSize;
m_numStaticElems += mesh->elemSize;
}
if( m_currNumStaticVerts >= MAX_BANKSIZE_VERTEXBUFFER )
{
m_bankSize[ m_numBank ] = m_prevNumStaticVerts;
m_currNumStaticVerts -= m_prevNumStaticVerts;
m_numBank++;
}
mdl->m_bank = m_numBank;
m_prevNumStaticVerts = m_currNumStaticVerts;
}
void CMDLMng::EndOfCalcVertexBuffer()
{
if( m_currNumStaticVerts > 0 )
m_bankSize[ m_numBank++ ] = m_currNumStaticVerts;
}
void CMDLMng::RestoreVertexInfo( int mdlIdx )
{
CMDL *mdl = &m_MDLs[mdlIdx];
if( mdl->m_numBoneFrames > 1 ) return;
if( mdl->m_needDynVB ) return;
if( mdl->m_storedMeshes == NULL ) return;
memcpy( mdl->m_meshes, mdl->m_storedMeshes, sizeof( mdlmesh_t ) * mdl->m_iStoredMeshesSize );
}
int CMDLMng::UploadVertexBuffer()
{
int i , j , k;
mdlvertex_t *vert;
element_t *elem;
int currBank;
int currNumStaticVerts , currNumStaticElems;
int elemSize;
WORD *ptrEB , *ptrStaticEB;
mdlvertex_t *ptrStaticVB;
CMDL *mdl;
mdlmesh_t *mesh;
if( m_bankSize[0] <= 0 ) return true;
ptrStaticVB = (mdlvertex_t *) m_staticVB[0]->Lock();
ptrStaticEB = (WORD *) m_staticEB->Lock();
currBank = 0;
currNumStaticVerts = 0;
currNumStaticElems = 0;
for( i = 0 ; i < m_numMDLs ; i++ )
{
mdl = GetMDL( i );
if( mdl == NULL ) continue;
if( mdl->m_numBoneFrames > 1 ) continue;
if( mdl->m_needDynVB ) continue;
mdl->m_storedMeshes = new mdlmesh_t[mdl->m_iStoredMeshesSize];
mdl->m_baseVB = currNumStaticVerts;
mdl->m_baseEB = currNumStaticElems;
mdl->m_sizeVB = 0;
mdl->m_sizeEB = 0;
if( currBank != mdl->m_bank )
{
m_staticVB[ currBank ]->Unlock();
ptrStaticVB = (mdlvertex_t *) m_staticVB[ mdl->m_bank ]->Lock();
currBank = mdl->m_bank;
currNumStaticVerts = 0;
}
mesh = &mdl->m_meshes[0];
for( j = 0 ; j < mdl->m_numMeshes ; j++ , mesh++ )
{
mesh->offsetVB = currNumStaticVerts;
mesh->offsetEB = currNumStaticElems;
vert = &mdl->m_vertices[ mesh->vertexOffset ];
memcpy( ptrStaticVB , vert , sizeof( mdlvertex_t ) * mesh->numVertices );
elem = &mdl->m_elems[ mesh->elemOffset ];
elemSize = mesh->numElems;
ptrEB = ptrStaticEB;
for( k = 0 ; k < elemSize ; k++ , elem++ , ptrEB++ )
*ptrEB = (WORD) ( currNumStaticVerts + *elem );
mesh->sizeVB = mesh->numVertices;
mesh->sizeEB = mesh->numElems;
currNumStaticVerts += mesh->sizeVB;
currNumStaticElems += mesh->sizeEB;
ptrStaticVB += mesh->sizeVB;
ptrStaticEB += mesh->sizeEB;
mdl->m_sizeVB += mesh->sizeVB;
mdl->m_sizeEB += mesh->sizeEB;
}
memcpy( mdl->m_storedMeshes, mdl->m_meshes, sizeof( mdlmesh_t ) * mdl->m_iStoredMeshesSize );
}
m_staticVB[ currBank ]->Unlock();
m_staticEB->Unlock();
return true;
}
int CMDLMng::LoadMDL( char *MDLName )
{
int i;
CMDL *mdl;
int ret;
for( i = 0 ; i < m_numMDLs ; i++ )
{
if( !stricmp( MDLName , m_MDLs[i].m_name ) )
break;
}
if( i < m_numMDLs )
return i;
if( m_numMDLs >= MAX_SIZE_MDL )
{
assert( m_numMDLs < MAX_SIZE_MDL );
GTH_ERROR( GTH_ERROR_PRINT , "MDL overflow.." );
return -1;
}
mdl = &m_MDLs[ m_numMDLs ];
mdl->SetFileMng( m_fileMng );
g_fileMng.SetResourceManager( &m_resManager );
mdl->SetMDLManager( this );
ret = mdl->Load( MDLName );
PrepareMDLShader( m_numMDLs );
CalcVertexBuffer( mdl );
if( !ret )
{
return -1;
}
m_numMDLs++;
return m_numMDLs - 1;
}
void CMDLMng::BindSoundSample ()
{
int index, subindex;
for ( index = 0; \
index < g_soundMng ->m_nummdlSoundID; \
++index )
{
for ( subindex = 0; \
subindex < m_numMDLs; \
++subindex )
{
if ( ! stricmp ( g_soundMng ->m_mdlSoundID [index].mdlname, m_MDLs [subindex].m_name ) )
{
m_MDLs [subindex].m_soundIdx = g_soundMng ->m_mdlSoundID [index].idx;
break;
}
}
}
}
| C++ |
#include "../global_def.h"
CMDL::CMDL()
{
m_buffer = NULL;
m_storedMeshes = NULL;
m_iBufferSize = 0;
m_soundIdx = -1;
}
CMDL::~CMDL()
{
GTH_SAFE_FREE ( m_buffer );
GTH_SAFE_FREE ( m_storedMeshes );
}
void CMDL::Release()
{
GTH_SAFE_FREE ( m_buffer );
GTH_SAFE_FREE ( m_storedMeshes );
}
#define lump_data(x) (m_buffer+head->lumps[(x)].offset)
#define lump_size(x) (head->lumps[(x)].size)
bool CMDL::Create( char *fname, int iSize )
{
mdlhead_t *head;
int i;
char *ext;
strcpy( m_name , fname );
m_iBufferSize = iSize;
m_buffer = m_fileMng->ReadFileFromPack( m_name );
if( !m_buffer )
{
if( ext = CFileMng::GetFileExt( m_name ) ) strcpy( ext , "mdl" );
else strcat( m_name , ".mdl" );
m_buffer = m_fileMng->ReadFileFromPack( m_name );
if( !m_buffer ) return false;
}
head = (mdlhead_t *) m_buffer;
m_boneFrames = (mdlboneframe_t *) lump_data( GTH_MODEL_BONEFRAME );
m_numBoneFrames = lump_size( GTH_MODEL_BONEFRAME ) / sizeof( mdlboneframe_t );
m_tags = (mdltag3x3_t *) lump_data( GTH_MODEL_TAG );
m_numTags = lump_size( GTH_MODEL_TAG ) / sizeof( mdltag3x3_t );
m_meshes = (mdlmesh_t *) lump_data( GTH_MODEL_MESH );
m_numMeshes = lump_size( GTH_MODEL_MESH ) / sizeof( mdlmesh_t );
m_shaderRefs = (mdlshaderref_t *) lump_data( GTH_MODEL_SHADERREFS );
m_numShaderRefs = lump_size( GTH_MODEL_SHADERREFS ) / sizeof( mdlshaderref_t );
m_vertices = (mdlvertex_t *) lump_data( GTH_MODEL_VERTICES );
m_numVertices = lump_size( GTH_MODEL_VERTICES ) / sizeof( mdlvertex_t );
m_elems = (element_t *) lump_data( GTH_MODEL_ELEMENTS );
m_numElems = lump_size( GTH_MODEL_ELEMENTS ) / sizeof( element_t );
m_boundVertices = (mdlboundvertex_t *) lump_data( GTH_MODEL_BOUND_VERTICES );
m_numBoundVertices = lump_size( GTH_MODEL_BOUND_VERTICES ) / sizeof( mdlboundvertex_t );
m_boundElems = (element_t *) lump_data( GTH_MODEL_BOUND_ELEMENTS );
m_numBoundElems = lump_size( GTH_MODEL_BOUND_ELEMENTS ) / sizeof( element_t );
m_boundPlanes = (mdlboundplane_t *) lump_data( GTH_MODEL_BOUND_PLANES );
m_numBoundPlanes = lump_size( GTH_MODEL_BOUND_PLANES ) / sizeof( mdlboundplane_t );
m_boundMeshes = (mdlboundmesh_t *) lump_data( GTH_MODEL_BOUND_MESH );
m_numBoundMeshes = lump_size( GTH_MODEL_BOUND_MESH ) / sizeof( mdlboundmesh_t );
VectorCopy( m_mins , head->mins );
VectorCopy( m_maxs , head->maxs );
ClearBounds( m_mins , m_maxs );
for( i = 0 ; i < m_numVertices ; i++ )
AddPointToBounds( m_vertices[i].point , m_mins , m_maxs );
m_numFrameVertices = 0;
m_numFrameElems = 0;
for( i = 0 ; i < m_numMeshes ; i++ )
{
m_numFrameVertices += m_meshes[i].numVertices;
m_numFrameElems += m_meshes[i].numElems;
}
for( i = 0 ; i < m_numShaderRefs ; i++ )
{
CFileMng::ConvertUnixPath( m_shaderRefs[i].name );
if( ext = CFileMng::GetFileExt( m_shaderRefs[i].name ) ) *( ext - 1 ) = 0;
}
m_iStoredMeshesSize = m_numMeshes;
return true;
}
bool CMDL::Recreate()
{
mdlhead_t *head;
int i;
char *ext;
m_buffer = m_fileMng->ReadFileFromPack( m_name );
if( !m_buffer )
{
if( ext = CFileMng::GetFileExt( m_name ) ) strcpy( ext , "mdl" );
else strcat( m_name , ".mdl" );
m_buffer = m_fileMng->ReadFileFromPack( m_name );
if( !m_buffer ) return false;
}
head = (mdlhead_t *) m_buffer;
m_boneFrames = (mdlboneframe_t *) lump_data( GTH_MODEL_BONEFRAME );
m_numBoneFrames = lump_size( GTH_MODEL_BONEFRAME ) / sizeof( mdlboneframe_t );
m_tags = (mdltag3x3_t *) lump_data( GTH_MODEL_TAG );
m_numTags = lump_size( GTH_MODEL_TAG ) / sizeof( mdltag3x3_t );
m_meshes = (mdlmesh_t *) lump_data( GTH_MODEL_MESH );
m_numMeshes = lump_size( GTH_MODEL_MESH ) / sizeof( mdlmesh_t );
m_shaderRefs = (mdlshaderref_t *) lump_data( GTH_MODEL_SHADERREFS );
m_numShaderRefs = lump_size( GTH_MODEL_SHADERREFS ) / sizeof( mdlshaderref_t );
m_vertices = (mdlvertex_t *) lump_data( GTH_MODEL_VERTICES );
m_numVertices = lump_size( GTH_MODEL_VERTICES ) / sizeof( mdlvertex_t );
m_elems = (element_t *) lump_data( GTH_MODEL_ELEMENTS );
m_numElems = lump_size( GTH_MODEL_ELEMENTS ) / sizeof( element_t );
m_boundVertices = (mdlboundvertex_t *) lump_data( GTH_MODEL_BOUND_VERTICES );
m_numBoundVertices = lump_size( GTH_MODEL_BOUND_VERTICES ) / sizeof( mdlboundvertex_t );
m_boundElems = (element_t *) lump_data( GTH_MODEL_BOUND_ELEMENTS );
m_numBoundElems = lump_size( GTH_MODEL_BOUND_ELEMENTS ) / sizeof( element_t );
m_boundPlanes = (mdlboundplane_t *) lump_data( GTH_MODEL_BOUND_PLANES );
m_numBoundPlanes = lump_size( GTH_MODEL_BOUND_PLANES ) / sizeof( mdlboundplane_t );
m_boundMeshes = (mdlboundmesh_t *) lump_data( GTH_MODEL_BOUND_MESH );
m_numBoundMeshes = lump_size( GTH_MODEL_BOUND_MESH ) / sizeof( mdlboundmesh_t );
VectorCopy( m_mins , head->mins );
VectorCopy( m_maxs , head->maxs );
ClearBounds( m_mins , m_maxs );
for( i = 0 ; i < m_numVertices ; i++ )
AddPointToBounds( m_vertices[i].point , m_mins , m_maxs );
m_numFrameVertices = 0;
m_numFrameElems = 0;
for( i = 0 ; i < m_numMeshes ; i++ )
{
m_numFrameVertices += m_meshes[i].numVertices;
m_numFrameElems += m_meshes[i].numElems;
}
for( i = 0 ; i < m_numShaderRefs ; i++ )
{
CFileMng::ConvertUnixPath( m_shaderRefs[i].name );
if( ext = CFileMng::GetFileExt( m_shaderRefs[i].name ) ) *( ext - 1 ) = 0;
}
return true;
}
int CMDL::Load( char *fname )
{
char *ext;
strcpy( m_name , fname );
if( !g_fileMng.RegisterFileFromPack( m_name, (RHANDLE)this, this ) )
{
if( ext = CFileMng::GetFileExt( m_name ) )
strcpy( ext , "mdl" );
else
strcat( m_name , ".mdl" );
if( !g_fileMng.RegisterFileFromPack( m_name, (RHANDLE)this, this ) ) return false;
}
return true;
}
int CMDL::GetShaderRef( mdlshaderref_t **shaderRef )
{
*shaderRef = m_shaderRefs;
return m_numShaderRefs;
}
void CMDL::GenNormals()
{
int sizeVertex;
int sizeElem;
int sizeFrame;
mdlmesh_t *mesh;
int i, j, k;
vec3_t face[3];
vec3_t normal;
mdlvertex_t *vertices;
element_t *elems;
for( i = 0 ; i < m_numMeshes ; i++ )
{
mesh = &m_meshes[ i ];
sizeVertex = mesh->numVertices;
sizeElem = mesh->numElems;
sizeFrame = mesh->numMeshFrames;
for( j = 0 ; j < sizeFrame ; j++ )
{
vertices = &m_vertices[ mesh->vertexOffset + sizeVertex * j ];
for( k = 0 ; k < sizeVertex ; k++ )
{
VectorClear( vertices[ k ].normal );
}
}
elems = &m_elems[ mesh->elemOffset ];
for( j = 0 ; j < sizeFrame ; j++ )
{
vertices = &m_vertices[ mesh->vertexOffset + sizeVertex * j ];
for( k = 0 ; k < sizeElem ; k += 3 )
{
VectorCopy( face[0] , vertices[ elems[ k ] ].point );
VectorCopy( face[1] , vertices[ elems[ k + 1 ] ].point );
VectorCopy( face[2] , vertices[ elems[ k + 2 ] ].point );
MakeTriNormal( (float*) face , normal );
VectorAdd( vertices[ elems[ k ] ].normal , normal , vertices[ elems[ k ] ].normal );
VectorAdd( vertices[ elems[ k + 1 ] ].normal , normal , vertices[ elems[ k + 1 ] ].normal );
VectorAdd( vertices[ elems[ k + 2 ] ].normal , normal , vertices[ elems[ k + 2 ] ].normal );
}
for( k = 0 ; k < sizeVertex ; k++ )
VectorScale( vertices[ k ].normal , vertices[ k ].normal , 0.5f );
}
}
} | C++ |
#include "../global_def.h"
#include "CTerraLpack.h"
char* CTerraLpack::GetMessage(int Idx, int etc1, int etc2)
{
if(Idx >= m_vpMessage.size()) return m_pUnknownMsg_RangeOverflow_Etc;
if(etc1 >= GetVector(Idx)->size() ) return m_pUnknownMsg_RangeOverflow_String;
std::string* pString = (std::string*)(*GetVector(Idx))[etc1];
return (char*)pString->c_str();
}
void CTerraLpack::Init()
{
m_vpMessage.reserve(MaxTypeNum);
m_NowvpIdx = 0;
for (int i = 0; i < MaxTypeNum; i++){
std::vector< void* >* pMessageVector = new std::vector< void* >;
m_vpMessage.push_back(pMessageVector);
}
}
void CTerraLpack::Destroy()
{
for (int i = 0; i < m_vpMessage.size(); i++ )
{
for (int p = 0; p < m_vpMessage[i]->size(); p++)
{
std::string* pString = (std::string*)(*GetVector(i))[p];
delete pString;
}
m_vpMessage[i]->clear();
delete m_vpMessage[i];
}
m_vpMessage.clear();
}
bool CTerraLpack::LoadFile(char* filename)
{
BYTE* pFileBuffer = NULL;
BYTE* ptempBuffer = NULL;
char TokenBuffer[TEMPBUFFER_SIZE];
int LineSize[LPACK_MAX_LINESIZE];
char Token,tempToken;
int TokenBufferPos;
char SentenseOpen;
int BufferPos;
int Checkwon;
int RowCount;
TokenBufferPos = 0;
SentenseOpen = 0;
Checkwon = 0;
BufferPos = 0;
RowCount = 0;
if (m_pFileMng != NULL)
pFileBuffer = m_pFileMng->ReadFileFromPack(filename);
if ( pFileBuffer == NULL ) return 0;
ptempBuffer = pFileBuffer;
memset ( TokenBuffer,0, sizeof( TokenBuffer ) );
memset ( LineSize, 0, sizeof( LineSize ) );
while (ptempBuffer[BufferPos] != NULL)
{
Token=ptempBuffer[BufferPos++];
if( IsDBCSLeadByte( (BYTE)Token ) )
{
TokenBuffer[TokenBufferPos++]=Token;
Token=ptempBuffer[BufferPos++];
TokenBuffer[TokenBufferPos++]=Token;
continue;
}
switch (Token)
{
case LPACK_SEMICOLON :
if (SentenseOpen)
{
TokenBuffer[TokenBufferPos++]=Token;
}
else
{
while (Token!=LPACK_LINEFEED && ptempBuffer[BufferPos]!=NULL)
{
Token=ptempBuffer[BufferPos++];
}
}
break;
case LPACK_COLON :
if (!SentenseOpen)
{
}
else
{
TokenBuffer[TokenBufferPos++]=Token;
}
break;
case LPACK_BACKSLASH :
if (SentenseOpen)
{
tempToken=ptempBuffer[BufferPos++];
if (tempToken=='\\')
TokenBuffer[TokenBufferPos++]=' ';
else
if (tempToken=='n')
TokenBuffer[TokenBufferPos++]='\n';
}
break;
case LPACK_RETURN :
break;
case LPACK_LINEFEED :
if(0 == strcmp("[TERRA]", TokenBuffer))
m_LPackType = LPACK_TYPE_TERRA;
else if(0 == strcmp ("[BILLING]", TokenBuffer))
m_NowvpIdx = type_Billing;
else if ( strcmp ("[HACK SHIELD]", TokenBuffer) == 0)
m_NowvpIdx = type_HackShield;
memset(TokenBuffer,0,TEMPBUFFER_SIZE);
TokenBufferPos=0;
break;
case LPACK_QUOTATION :
if (!SentenseOpen )
{
SentenseOpen=1;
memset(TokenBuffer,0,TEMPBUFFER_SIZE);
TokenBufferPos=0;
}
else
{
SentenseOpen=0;
LineSize[RowCount++]=strlen(TokenBuffer);
std::string* str = new std::string;
(*str) = TokenBuffer;
std::vector<void*>* pvector = GetVector(m_NowvpIdx);
pvector->push_back((void*)str);
memset(TokenBuffer, 0, TEMPBUFFER_SIZE);
TokenBufferPos=0;
Token=ptempBuffer[BufferPos++];
while (Token!=LPACK_LINEFEED && ptempBuffer[BufferPos]!=NULL)
{
Token=ptempBuffer[BufferPos++];
}
}
break;
default :
TokenBuffer[TokenBufferPos++]=Token;
break;
}
}
GTH_SAFE_FREE( pFileBuffer );
return TRUE;
} | C++ |
#ifndef __VEMER_COMMON_H__
#define __VEMER_COMMON_H__
#include "stdafx.h"
#pragma once
#define chSTR2(x) #x
#define chSTR(x) chSTR2(x)
#define chMSG(desc) message(__FILE__ "(" chSTR(__LINE__) ") : message : " #desc)
#define chINRANGE(low, Num, High) (((low) <= (Num)) && ((Num) <= (High)))
#define chDIMOF(Array) (sizeof(Array) / sizeof(Array[0]))
#define chSIZEOFSTRING(psz) ((lstrlen(psz) + 1) * sizeof(TCHAR))
template <class TV, class TM>
inline TV chROUNDDOWN(TV Value, TM Multiple) {
return((Value / Multiple) * Multiple);
}
template <class TV, class TM>
inline TV chROUNDUP(TV Value, TM Multiple) {
return(chROUNDDOWN(Value, Multiple) +
(((Value % Multiple) > 0) ? Multiple : 0));
}
#ifdef _X86_
#define DebugBreak() _asm { int 3 }
#endif
#define MAKESOFTWAREEXCEPTION(Severity, Facility, Exception) \
((DWORD) ( \
(Severity ) | \
(1 << 29) | \
(0 << 28) | \
(Facility << 16) | \
(Exception << 0)))
inline void chMB(PCSTR s) {
char szTMP[256];
GetModuleFileNameA(NULL, szTMP, chDIMOF(szTMP));
HWND hwnd = GetActiveWindow();
}
inline void chMBANDDEBUG(PSTR szMsg) {
chMB(szMsg);
DebugBreak();
}
inline void chASSERTFAIL(LPCSTR file, int line, PCSTR expr) {
char sz[256];
wsprintfA(sz, "File %s, line %d : %s", file, line, expr);
chMBANDDEBUG(sz);
}
#ifdef _DEBUG
#define chASSERT(x) if (!(x)) chASSERTFAIL(__FILE__, __LINE__, #x)
#else
#define chASSERT(x)
#endif
#ifdef _DEBUG
#define chFAIL() chASSERTFAIL(__FILE__, __LINE__, "")
#else
#define chFAIL()
#endif
#ifdef _DEBUG
#define chVERIFY(x) chASSERT(x)
#else
#define chVERIFY(x) (x)
#endif
#define chHANDLE_DLGMSG(hwnd, message, fn) \
case (message): return (SetDlgMsgResult(hwnd, uMsg, \
HANDLE_##message((hwnd), (wParam), (lParam), (fn))))
inline void chSETDLGICONS(HWND hwnd, int idi) {
SendMessage(hwnd, WM_SETICON, TRUE, (LPARAM)
LoadIcon((HINSTANCE) GetWindowLong(hwnd, GWL_HINSTANCE),
MAKEINTRESOURCE(idi)));
SendMessage(hwnd, WM_SETICON, FALSE, (LPARAM)
LoadIcon((HINSTANCE) GetWindowLong(hwnd, GWL_HINSTANCE),
MAKEINTRESOURCE(idi)));
}
extern bool InitLogWnd(HWND hParentWnd);
#endif | C++ |
#ifndef _LOG_H_
#define _LOG_H_
class CLogSystem
{
private:
time_t m_logTime;
FILE *m_fpLog;
FILE *m_fpDebug;
char m_logFileName[64];
char m_debugFileName[64];
unsigned int m_updateTime;
int m_updateCycle;
int m_generationHour;
int m_createLog;
int m_createDebug;
FILE *m_fpError;
int m_createError;
public:
CLogSystem();
~CLogSystem();
void Initialize(int createLog, int createDebug);
int Open();
int Close();
int Update();
void Write( const char *format, ... );
void WriteToError( const char *format, ... );
void WriteToLog( const char *format, ... );
};
enum
{
LOG_CLASS_LEVELUP = 0,
LOG_CLASS_GENLEVELUP,
LOG_CLASS_ITEM,
LOG_CLASS_PCDIE,
LOG_CLASS_CONNECT,
LOG_CLASS_DISCONNECT,
LOG_CLASS_PCCREATE,
LOG_CLASS_PCDELETE,
LOG_CLASS_PCERROR,
};
enum
{
LOG_CLASS_ITEM_PICKUP = 0,
LOG_CLASS_ITEM_DROP,
LOG_CLASS_ITEM_STACK,
LOG_CLASS_ITEM_BUY_STORE,
LOG_CLASS_ITEM_SELL_STORE,
LOG_CLASS_ITEM_LEARN_SKILL,
LOG_CLASS_ITEM_SKILL_SCROLL,
LOG_CLASS_ITEM_USE_PORTAL,
LOG_CLASS_ITEM_DESTROY,
LOG_CLASS_ITEM_CONFIRM_TRADE,
LOG_CLASS_ITEM_UNDO_TRADE,
LOG_CLASS_ITEM_ADD_QUEST,
LOG_CLASS_ITEM_DEL_QUEST,
LOG_CLASS_ITEM_DIE_DROP,
LOG_CLASS_ITEM_DIE_DESTROY,
LOG_CLASS_ITEM_COMPLETE_CRAFT,
LOG_CLASS_ITEM_CRAFT_SOURCE,
LOG_CLASS_ITEM_CRAFT_RESULT,
LOG_CLASS_ITEM_UNDO_CRAFT,
LOG_CLASS_ITEM_UNDO_BOOTH,
LOG_CLASS_ITEM_SELL_BOOTH,
LOG_CLASS_ITEM_BUY_BOOTH,
LOG_CLASS_ITEM_COMPLETE_UPGRADE,
LOG_CLASS_ITEM_UPGRADE_SOURCE,
LOG_CLASS_ITEM_UPGRADE_RESULT,
LOG_CLASS_ITEM_UNDO_UPGRADE,
};
enum
{
LOG_CLASS_ITEM_MISSMATCH = 0,
};
enum
{
LOG_CLASS_ITEM_MISSMATCH_TYPE_SAVE = 0,
LOG_CLASS_ITEM_MISSMATCH_TYPE_TRADE,
LOG_CLASS_ITEM_MISSMATCH_TYPE_CRAFT,
LOG_CLASS_ITEM_MISSMATCH_TYPE_UPGRADE,
LOG_CLASS_ITEM_MISSMATCH_TYPE_BOOTH,
LOG_CLASS_ITEM_MISSMATCH_TYPE_AUTOQUESTCRAFT,
};
char* GetItemInformationLog( int isStack, int itemTableIdx, int itemIdx, int inventoryPos );
#endif
| C++ |
#include <windows.h>
#include <STDIO.H>
#include "VUtil.h"
__int64 g_qnTotalPC, g_qnFreq, g_qnCurrPC;
void ShowLogInfo(char *pszFmtMsg, ...);
void ShowLogInfo(char *pszFmtMsg, ...)
{
#ifndef _DEBUG
return;
#endif
DWORD dwTime;
va_list valArg;
char szTime[60];
char szMsg[4096];
DWORD dwThreadID = GetCurrentThreadId();
dwTime = GetTickCount();
wsprintf(szTime, "[info] thrd=%d ", dwThreadID);
va_start(valArg, pszFmtMsg);
wvsprintf( szMsg, pszFmtMsg, valArg );
va_end(valArg);
#ifdef __MYDEBUG
#ifdef SHOW_LOG_SCREEN
#ifdef MT_CLIENT
OutputDebugString(szTime);
OutputDebugString(szMsg);
OutputDebugString("\r\n");
#else
printf(szTime);
printf(szMsg);
printf("\r\n");
#endif
#endif
#endif
}
void InitProfile()
{
QueryPerformanceFrequency( (LARGE_INTEGER*) &g_qnFreq);
QueryPerformanceCounter((LARGE_INTEGER*) &g_qnCurrPC);
g_qnTotalPC = 0;
}
void ShowProfile()
{
double dDiff, dFreq;
dDiff = (double)g_qnTotalPC;
dFreq = (double)g_qnFreq;
dDiff = dDiff/g_qnFreq;
}
void StartProfile()
{
QueryPerformanceCounter((LARGE_INTEGER*) &g_qnCurrPC);
}
void EndProfile(char* pMsg)
{
__int64 qnPC;
int nDiffPC;
float fDiff, fFreq;
QueryPerformanceCounter((LARGE_INTEGER*)&qnPC);
nDiffPC = (int)(qnPC - g_qnCurrPC);
g_qnTotalPC += nDiffPC;
fDiff = (float)nDiffPC;
fFreq = (float)g_qnFreq;
fDiff = fDiff/fFreq;
}
void WriteToLog( const char *format, ... )
{
//#ifndef _DEBUG
// return;
//#endif
FILE *LogFP = NULL;
LogFP = fopen ( "..\\LogFile.txt", "a+");
if ( LogFP == NULL)
return;
va_list argptr;
char buffer[4096];
char timestr [60];
SYSTEMTIME time;
memset(&time, 0, sizeof(SYSTEMTIME) );
GetLocalTime(&time);
wsprintf(timestr, "[%d.%d.%d %d:%d:%d] ",
time.wYear, time.wMonth,
time.wDay, time.wHour,
time.wMinute, time.wMilliseconds );
va_start(argptr, format);
vsprintf(buffer, format, argptr);
va_end(argptr);
OutputDebugString(timestr);
OutputDebugString(buffer);
OutputDebugString("\r\n");
fprintf(LogFP, "%s", timestr);
fprintf(LogFP, "%s\n", buffer);
fclose(LogFP);
}
| C++ |
#include <windows.h>
#include <stdio.h>
#include <time.h>
#include <vector>
#include <string>
#include "Ahndbglog.h"
#if _MSC_VER > 1000
#pragma once
#endif
#pragma warning(disable: 4786)
using namespace std;
#define gle (GetLastError())
#define lenof(a) (sizeof(a) / sizeof((a)[0]))
#define MAXNAMELEN 128
#define IMGSYMLEN (sizeof (IMAGEHLP_SYMBOL))
#define TTBUFLEN 512
typedef BOOL (__stdcall *tSC)(IN HANDLE hProcess);
typedef PVOID (__stdcall *tSFTA)(HANDLE hProcess, DWORD AddrBase);
typedef BOOL (__stdcall *tSGLFA)(IN HANDLE hProcess, IN DWORD dwAddr,
OUT PDWORD pdwDisplacement, OUT PIMAGEHLP_LINE Line);
typedef DWORD (__stdcall *tSGMB)(IN HANDLE hProcess, IN DWORD dwAddr);
typedef BOOL (__stdcall *tSGMI)(IN HANDLE hProcess, IN DWORD dwAddr, OUT PIMAGEHLP_MODULE ModuleInfo);
typedef DWORD (__stdcall *tSGO)(VOID);
typedef BOOL (__stdcall *tSGSFA)(IN HANDLE hProcess, IN DWORD dwAddr,
OUT PDWORD pdwDisplacement, OUT PIMAGEHLP_SYMBOL Symbol);
typedef BOOL (__stdcall *tSI)(IN HANDLE hProcess, IN PSTR UserSearchPath, IN BOOL fInvadeProcess);
typedef DWORD (__stdcall *tSLM)(IN HANDLE hProcess, IN HANDLE hFile,
IN PSTR ImageName, IN PSTR ModuleName,
IN DWORD BaseOfDll, IN DWORD SizeOfDll);
typedef DWORD (__stdcall *tSSO)(IN DWORD SymOptions);
typedef BOOL (__stdcall *tSW)(DWORD MachineType, HANDLE hProcess,
HANDLE hThread, LPSTACKFRAME StackFrame, PVOID ContextRecord,
PREAD_PROCESS_MEMORY_ROUTINE ReadMemoryRoutine,
PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine,
PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine,
PTRANSLATE_ADDRESS_ROUTINE TranslateAddress);
typedef DWORD (__stdcall WINAPI *tUDSN)(PCSTR DecoratedName, PSTR UnDecoratedName,
DWORD UndecoratedLength, DWORD Flags);
struct StackFunction
{
HINSTANCE pLib;
tSC pSC;
tSFTA pSFTA;
tSGLFA pSGLFA;
tSGMB pSGMB;
tSGMI pSGMI;
tSGO pSGO;
tSGSFA pSGSFA;
tSI pSI;
tSLM pSLM;
tSSO pSSO;
tSW pSW;
tUDSN pUDSN;
};
struct ModuleEntry
{
std::string imageName;
std::string moduleName;
DWORD baseAddress;
DWORD size;
};
typedef std::vector< ModuleEntry > ModuleList;
typedef ModuleList::iterator ModuleListIter;
void ShowStack(HANDLE hThread, CONTEXT& c);
bool fillModuleList(ModuleList& modules, DWORD pid, FILE* file);
StackFunction* g_SEHfunction = NULL;
void SEHinitProcess(void)
{
if(g_SEHfunction == NULL)
{
g_SEHfunction = new StackFunction;
memset(g_SEHfunction, 0, sizeof(StackFunction));
g_SEHfunction->pLib = LoadLibrary("imagehlp.dll");
if(g_SEHfunction->pLib != NULL)
{
g_SEHfunction->pSC = (tSC) GetProcAddress(g_SEHfunction->pLib, "SymCleanup");
g_SEHfunction->pSFTA = (tSFTA) GetProcAddress(g_SEHfunction->pLib, "SymFunctionTableAccess");
g_SEHfunction->pSGLFA = (tSGLFA) GetProcAddress(g_SEHfunction->pLib, "SymGetLineFromAddr");
g_SEHfunction->pSGMB = (tSGMB) GetProcAddress(g_SEHfunction->pLib, "SymGetModuleBase");
g_SEHfunction->pSGMI = (tSGMI) GetProcAddress(g_SEHfunction->pLib, "SymGetModuleInfo");
g_SEHfunction->pSGO = (tSGO) GetProcAddress(g_SEHfunction->pLib, "SymGetOptions");
g_SEHfunction->pSGSFA = (tSGSFA) GetProcAddress(g_SEHfunction->pLib, "SymGetSymFromAddr");
g_SEHfunction->pSI = (tSI) GetProcAddress(g_SEHfunction->pLib, "SymInitialize");
g_SEHfunction->pSSO = (tSSO) GetProcAddress(g_SEHfunction->pLib, "SymSetOptions");
g_SEHfunction->pSW = (tSW) GetProcAddress(g_SEHfunction->pLib, "StackWalk");
g_SEHfunction->pUDSN = (tUDSN) GetProcAddress(g_SEHfunction->pLib, "UnDecorateSymbolName");
g_SEHfunction->pSLM = (tSLM) GetProcAddress(g_SEHfunction->pLib, "SymLoadModule");
}
}
}
DWORD SEHlogProcess(EXCEPTION_POINTERS *ep)
{
HANDLE hThread;
DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
GetCurrentProcess(), &hThread,
0, false, DUPLICATE_SAME_ACCESS);
ShowStack(hThread, *(ep->ContextRecord));
CloseHandle(hThread);
return EXCEPTION_EXECUTE_HANDLER;
}
void ShowStack(HANDLE hThread, CONTEXT& c)
{
DWORD imageType = IMAGE_FILE_MACHINE_I386;
HANDLE hProcess = GetCurrentProcess();
int frameNum;
DWORD offsetFromSymbol;
DWORD symOptions;
IMAGEHLP_SYMBOL *pSym = (IMAGEHLP_SYMBOL*) malloc(IMGSYMLEN + MAXNAMELEN);
char undName[MAXNAMELEN];
char undFullName[MAXNAMELEN];
IMAGEHLP_MODULE Module;
IMAGEHLP_LINE Line;
std::string symSearchPath;
char *tt = NULL, *p;
STACKFRAME s;
memset(&s, '\0', sizeof(s));
tt = new char[TTBUFLEN];
char fname[128];
time_t clock;
tm* newtime;
time(&clock);
newtime = localtime( &clock );
wsprintf(fname, "../weo-%d%02d%02d-%02d-%02d-%02d.dbg",
newtime->tm_year+1900, newtime->tm_mon+1,
newtime->tm_mday, newtime->tm_hour,
newtime->tm_min, newtime->tm_sec);
if((symOptions = GetModuleFileName(0, tt, TTBUFLEN)) != NULL)
{
p = tt + symOptions - 3;
strcpy(p, "dbg");
FILE* dbgfile = fopen(fname, "w");
if(dbgfile != NULL)
{
fprintf(dbgfile, "================================================================================\n");
fprintf(dbgfile, "== VANILLA Exception Report ver 0.01.00 ==\n");
fprintf(dbgfile, "================================================================================\n\n");
fprintf(dbgfile, "== <TIME INFO> == \n");
time(&clock);
if((newtime = localtime(&clock)) != NULL)
{
fprintf(dbgfile, " Reported Time : %s\n", asctime(newtime));
}
else
{
fprintf(dbgfile, " Reported Time : No data\n");
}
fprintf(dbgfile, "== <FILE INFO> == \n");
symSearchPath = "";
for ( p = tt + strlen( tt ) - 1; p >= tt; -- p )
{
if ( *p == '\\' || *p == '/' || *p == ':' )
break;
}
if ( p != tt )
{
if ( *p == ':' )
++ p;
*p = '\0';
symSearchPath += tt + std::string( ";" );
}
fprintf(dbgfile, " Working Directory : %s\n", tt);
if(!g_SEHfunction->pSI(hProcess, NULL, false))
{
fprintf(dbgfile, "\n ! Error in SymInitialize(): GetLastError No. = %lu\n", gle);
fprintf(dbgfile, "! Can't make report anymore");
}
else
{
symOptions = g_SEHfunction->pSGO();
symOptions |= SYMOPT_LOAD_LINES;
symOptions &= ~SYMOPT_UNDNAME;
g_SEHfunction->pSSO( symOptions );
fprintf(dbgfile, "\n== <MODULE INFO> == \n");
ModuleList modules;
ModuleListIter it;
char *img, *mod;
if(fillModuleList(modules, GetCurrentProcessId(), dbgfile))
{
fprintf(dbgfile, "\n== <SYMBOL INFO> == \n");
for(it = modules.begin(); it != modules.end(); ++ it)
{
img = new char[(*it).imageName.size() + 1];
strcpy(img, (*it).imageName.c_str());
mod = new char[(*it).moduleName.size() + 1];
strcpy(mod, (*it).moduleName.c_str());
if(g_SEHfunction->pSLM(hProcess, 0, img, mod, (*it).baseAddress, (*it).size) == 0)
{
fprintf(dbgfile, " Simbol not loaded : %s\n", (*it).moduleName.c_str());
}
else
{
fprintf(dbgfile, " Symbols loaded : %s\n", (*it).moduleName.c_str());
}
delete [] img;
delete [] mod;
}
s.AddrPC.Offset = c.Eip;
s.AddrPC.Mode = AddrModeFlat;
s.AddrFrame.Offset = c.Ebp;
s.AddrFrame.Mode = AddrModeFlat;
memset(pSym, '\0', IMGSYMLEN + MAXNAMELEN);
pSym->SizeOfStruct = IMGSYMLEN;
pSym->MaxNameLength = MAXNAMELEN;
memset(&Line, '\0', sizeof Line);
Line.SizeOfStruct = sizeof Line;
memset(&Module, '\0', sizeof Module);
Module.SizeOfStruct = sizeof Module;
offsetFromSymbol = 0;
fprintf(dbgfile, "\n== <CALL STACK INFO> == \n");
fprintf(dbgfile, "--------------------------------------------------------------------------------\n");
fprintf(dbgfile, " No | Far | Vir | EIP Addr | Ret Addr | Frame Ptr | Stack Ptr | Symbol & Offset\n");
fprintf(dbgfile, "--------------------------------------------------------------------------------\n");
for(frameNum = 0; ; ++frameNum)
{
if(!g_SEHfunction->pSW(imageType, hProcess, hThread, &s, &c, NULL, g_SEHfunction->pSFTA, g_SEHfunction->pSGMB, NULL)) break;
fprintf(dbgfile, " %3d | %c | %c | %08lx | %08lx | %09lx | %09lx |",
frameNum,
s.Far? 'F': '.',
s.Virtual? 'V': '.',
s.AddrPC.Offset,
s.AddrReturn.Offset,
s.AddrFrame.Offset,
s.AddrStack.Offset);
if(s.AddrPC.Offset == 0)
{
fprintf(dbgfile, "(-nosymbols- PC == 0)\n");
}
else
{
if(!g_SEHfunction->pSGSFA(hProcess, s.AddrPC.Offset, &offsetFromSymbol, pSym))
{
fprintf(dbgfile, " Error No. = %lu\n", gle);
fprintf(dbgfile, "--------------------------------------------------------------------------------\n");
fprintf(dbgfile, " Sig : Error No. = %lu\n", gle);
fprintf(dbgfile, " Decl : Error No. = %lu\n", gle);
}
else
{
g_SEHfunction->pUDSN(pSym->Name, undName, MAXNAMELEN, UNDNAME_NAME_ONLY);
g_SEHfunction->pUDSN(pSym->Name, undFullName, MAXNAMELEN, UNDNAME_COMPLETE);
fprintf(dbgfile, " %s", undName);
if(offsetFromSymbol != 0)
{
fprintf(dbgfile, " %+ld bytes", (long)offsetFromSymbol);
}
fprintf(dbgfile, "\n");
fprintf(dbgfile, "--------------------------------------------------------------------------------\n");
fprintf(dbgfile, " Sig : %s\n", pSym->Name);
fprintf(dbgfile, " Decl : %s\n", undFullName);
}
if(g_SEHfunction->pSGLFA != NULL)
{
if(!g_SEHfunction->pSGLFA(hProcess, s.AddrPC.Offset, &offsetFromSymbol, &Line))
{
fprintf(dbgfile, " Line : Error No. = %lu\n", gle);
}
else
{
fprintf(dbgfile, " Line : %s (%lu line), %+ld bytes\n",
Line.FileName,
Line.LineNumber,
offsetFromSymbol);
}
}
if(!g_SEHfunction->pSGMI(hProcess, s.AddrPC.Offset, &Module))
{
fprintf(dbgfile, " Module : Error No. = %lu\n", gle);
}
else
{
char ty[80];
switch(Module.SymType)
{
case SymNone:
strcpy(ty, "-nosymbols-");
break;
case SymCoff:
strcpy(ty, "COFF");
break;
case SymCv:
strcpy(ty, "CV");
break;
case SymPdb:
strcpy(ty, "PDB");
break;
case SymExport:
strcpy(ty, "-exported-");
break;
case SymDeferred:
strcpy(ty, "-deferred-");
break;
case SymSym:
strcpy(ty, "SYM");
break;
default:
_snprintf(ty, sizeof ty, "symtype = %ld", (long) Module.SymType);
break;
}
fprintf(dbgfile, " Module : %s[%s], base: %08lxh\n",
Module.ModuleName,
Module.ImageName,
Module.BaseOfImage);
fprintf(dbgfile, " Sym : |type| %s, |file| %s\n",
ty,
Module.LoadedImageName);
}
LPVOID lpMsgBuf;
FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, gle, 0, (LPTSTR) &lpMsgBuf, 0, NULL );
fprintf(dbgfile, "ErrorMsg : %s\n", (LPCTSTR)lpMsgBuf);
fprintf(dbgfile, "--------------------------------------------------------------------------------\n");
}
if(s.AddrReturn.Offset == 0)
{
SetLastError(0);
break;
}
}
char* stkPtr = (char*)(c.Esp);
fprintf(dbgfile, "\n== <STACK INFO> == \n");
fprintf(dbgfile, "Stack : 1024 bytes starting at (ESP = %08lx)\n", stkPtr);
fprintf(dbgfile, "--------------------------------------------------------------------------------\n");
for(int i = 0; i < 64; ++i)
{
fprintf(dbgfile, " %08lx : ", stkPtr);
for(int j = 0; j < 16; ++j, ++stkPtr)
{
fprintf(dbgfile, "%02hX ", (BYTE)*stkPtr);
if((j & 3) == 3) fprintf(dbgfile, " ");
}
stkPtr -= 16;
for(j = 0; j < 16; ++j, ++stkPtr)
{
if(*stkPtr < 32)
{
fprintf(dbgfile, ".");
}
else
{
fprintf(dbgfile, "%c", *stkPtr);
}
}
fprintf(dbgfile, "\n");
}
fprintf(dbgfile, "\n== <MEMORY INFO> == \n");
}
else
{
fprintf(dbgfile, "Error : Processing error in kernel32.dll & tlhelp32.dll, so we can't load symbol\n");
}
}
fclose(dbgfile);
ResumeThread(hThread);
g_SEHfunction->pSC(hProcess);
free(pSym);
delete [] tt;
}
}
}
#define MAX_MODULE_NAME32 255
#define TH32CS_SNAPMODULE 0x00000008
#pragma pack(push, 8)
typedef struct tagMODULEENTRY32
{
DWORD dwSize;
DWORD th32ModuleID;
DWORD th32ProcessID;
DWORD GlblcntUsage;
DWORD ProccntUsage;
BYTE* modBaseAddr;
DWORD modBaseSize;
HMODULE hModule;
char szModule[MAX_MODULE_NAME32 + 1];
char szExePath[MAX_PATH];
} MODULEENTRY32;
typedef MODULEENTRY32* PMODULEENTRY32;
typedef MODULEENTRY32* LPMODULEENTRY32;
#pragma pack(pop)
typedef HANDLE (__stdcall *tCT32S)( DWORD dwFlags, DWORD th32ProcessID );
typedef BOOL (__stdcall *tM32F)( HANDLE hSnapshot, LPMODULEENTRY32 lpme );
typedef BOOL (__stdcall *tM32N)( HANDLE hSnapshot, LPMODULEENTRY32 lpme );
bool fillModuleList(ModuleList& modules, DWORD pid, FILE* file)
{
const char *dllname[] = { "kernel32.dll", "tlhelp32.dll" };
HINSTANCE hToolhelp;
tCT32S pCT32S = NULL;
tM32F pM32F = NULL;
tM32N pM32N = NULL;
HANDLE hSnap;
MODULEENTRY32 me = { sizeof me };
bool keepGoing;
ModuleEntry e;
for(int i = 0; i < lenof( dllname ); ++ i)
{
hToolhelp = LoadLibrary(dllname[i]);
if(hToolhelp == NULL) continue;
pCT32S = (tCT32S) GetProcAddress(hToolhelp, "CreateToolhelp32Snapshot");
pM32F = (tM32F) GetProcAddress(hToolhelp, "Module32First");
pM32N = (tM32N) GetProcAddress(hToolhelp, "Module32Next");
if(pCT32S != 0 && pM32F != 0 && pM32N != 0) break;
FreeLibrary(hToolhelp);
hToolhelp = NULL;
}
if(hToolhelp == NULL) return false;
if((hSnap = pCT32S(TH32CS_SNAPMODULE, pid)) == (HANDLE) -1) return false;
fprintf(file, "--------------------------------------------------------------------------------\n");
fprintf(file, "BaseAddress | BaseSize | Path\n");
fprintf(file, "--------------------------------------------------------------------------------\n");
keepGoing = !!pM32F(hSnap, &me);
while(keepGoing)
{
fprintf(file, "%10lXh | %8lu | %s\n", me.modBaseAddr, me.modBaseSize, me.szExePath);
e.imageName = me.szExePath;
e.moduleName = me.szModule;
e.baseAddress = (DWORD) me.modBaseAddr;
e.size = me.modBaseSize;
modules.push_back(e);
keepGoing = !!pM32N(hSnap, &me);
}
CloseHandle(hSnap);
FreeLibrary(hToolhelp);
return true;
}
void SEHexitProcess(void)
{
FreeLibrary(g_SEHfunction->pLib);
delete g_SEHfunction;
}
| C++ |
#include "../global_def.h"
CLogSystem::CLogSystem()
{
m_updateTime = 0;
m_generationHour = -1;
}
CLogSystem::~CLogSystem()
{
}
void CLogSystem::Initialize(int createLog, int createDebug)
{
m_updateTime = g_timer.GetAppMilliTime();
m_updateCycle = 1000;
m_createLog = createLog;
m_createDebug = createDebug;
m_createError = true;
}
int CLogSystem::Open()
{
struct tm *date_tm;
time( &m_logTime );
date_tm = localtime( &m_logTime );
if (m_generationHour != date_tm->tm_hour)
{
m_generationHour = date_tm->tm_hour;
date_tm->tm_year += 1900;
date_tm->tm_mon += 1;
if ( m_createLog )
{
sprintf(m_logFileName, "logs/GS%02d%02d_%04d%02d%02d_%02d.log",
g_config.serverGroupNo, g_config.gameServerNo, date_tm->tm_year, date_tm->tm_mon, date_tm->tm_mday, date_tm->tm_hour);
}
if ( m_createDebug )
{
sprintf(m_debugFileName, "debugs/GS%02d%02d_%04d%02d%02d_%02d.dbg",
g_config.serverGroupNo, g_config.gameServerNo, date_tm->tm_year, date_tm->tm_mon, date_tm->tm_mday, date_tm->tm_hour);
}
}
if ( m_createLog )
{
m_fpLog = fopen( m_logFileName , "a+" );
if( !m_fpLog )
{
MessageBox(g_hWnd, "logs folder doesn't exist!!", "Error!", MB_OK);
return false;
}
}
if ( m_createDebug )
{
m_fpDebug = fopen( m_debugFileName , "a+" );
if( !m_fpDebug )
{
MessageBox(g_hWnd, "debugs folder doesn't exist!!", "Error!", MB_OK);
return false;
}
}
if( m_createError )
{
m_fpError = fopen( "error.dbg", "a+" );
if( !m_fpError )
{
MessageBox(g_hWnd, "Cannot open error.dbg file!!", "Error!", MB_OK);
return false;
}
}
return true;
}
int CLogSystem::Close()
{
if ( m_createLog )
{
if ( fclose(m_fpLog) != 0 )
return false;
}
if (m_createDebug )
{
if ( fclose(m_fpDebug) != 0 )
return false;
}
if( m_createError )
{
if( fclose( m_fpError ) != 0 )
return false;
}
return true;
}
int CLogSystem::Update()
{
if (m_updateTime > g_globalTime) return false;
m_updateTime = g_globalTime + m_updateCycle;
if ( !Close() ) return false;
if ( !Open() ) return false;
return true;
}
void CLogSystem::Write( const char *format, ... )
{
if ( !m_createDebug ) return;
va_list argptr;
char buffer[4096];
char cTime[26];
va_start(argptr, format);
vsprintf(buffer, format, argptr);
va_end(argptr);
time( &m_logTime );
strcpy(cTime, ctime(&m_logTime));
cTime[24] ='\0';
fprintf(m_fpDebug, "[%s] %s\n", cTime, buffer);
}
void CLogSystem::WriteToLog( const char *format, ... )
{
if ( !m_createLog ) return;
va_list argptr;
char buffer[4096];
char cTimeStamp[30];
timeStamp_t timeStamp;
va_start(argptr, format);
vsprintf(buffer, format, argptr);
va_end(argptr);
sprintf(cTimeStamp, "%4d-%02d-%02d %02d:%02d:%02d",
timeStamp.year, timeStamp.month, timeStamp.day, timeStamp.hour, timeStamp.minute, timeStamp.second);
fprintf(m_fpLog, "%s;%s\n", cTimeStamp, buffer);
}
void CLogSystem::WriteToError( const char *format, ... )
{
if ( !m_createError ) return;
va_list argptr;
char buffer[4096];
char cTime[26];
va_start(argptr, format);
vsprintf(buffer, format, argptr);
va_end(argptr);
time( &m_logTime );
strcpy(cTime, ctime(&m_logTime));
cTime[24] ='\0';
fprintf(m_fpError, "[%s] %s\n", cTime, buffer);
}
void
{
time_t curTime;
struct tm *date_tm;
time( &curTime );
date_tm = localtime( &curTime );
timeStamp->year = date_tm->tm_year += 1900;
timeStamp->month = date_tm->tm_mon += 1;
timeStamp->day = date_tm->tm_mday;
timeStamp->hour = date_tm->tm_hour;
timeStamp->minute = date_tm->tm_min;
timeStamp->second = date_tm->tm_sec;
timeStamp->fraction = 0;
}
char* GetItemInformationLog( int isStack, int itemTableIdx, int itemIdx, int inventoryPos )
{
static char buffer[100];
_snprintf( buffer, 100,
"isStack[%d] "
"itemTableIdx[%d] "
"itemIdx[%d] "
"invenPos[%d]"
,
isStack,
itemTableIdx,
itemIdx,
inventoryPos
);
return buffer;
}
| C++ |
#if !defined(AFX_LOGEVENT_H__A3DE815F_0CAF_408A_9BE7_5D60F70E33D0__INCLUDED_)
#define AFX_LOGEVENT_H__A3DE815F_0CAF_408A_9BE7_5D60F70E33D0__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CLogEvent
{
public:
enum
{
GTH_EVENTLOG_SUCCESS=0,
GTH_EVENTLOG_ERROR_TYPE,
GTH_EVENTLOG_WARNING_TYPE,
GTH_EVENTLOG_INFORMATION_TYPE,
GTH_EVENTLOG_AUDIT_SUCCESS,
GTH_EVENTLOG_AUDIT_FAILURE,
};
CLogEvent();
virtual ~CLogEvent();
void Init();
void LogEvent(WORD wType,LPCTSTR lpszFormat, ...);
void WriteLog(WORD wType,const char* szMessage);
BOOL AddEventSource(
LPTSTR pszLogName,
LPTSTR pszSrcName,
LPTSTR pszMsgDLL,
DWORD dwNum);
void ReStartLog();
public:
HANDLE m_hEventSource;
};
#endif
| C++ |
#include "../stdafx.h"
#include "XIME.h"
BOOL IsDBCS(LPCTSTR strBuf, int nPos)
{
BOOL bRet = FALSE;
for(int i = 0; i <= nPos; i++)
{
if(isascii(strBuf[i])==0)
{
{
if(nPos == i+1)
bRet = TRUE;
}
i++;
}
}
return bRet;
}
_XIMEContainer::_XIMEContainer()
{
ResetContainer();
}
_XIMEContainer::~_XIMEContainer()
{
}
void _XIMEContainer::ResetContainer( void )
{
m_length = 0;
m_MaxLength = MAX_IMEBUFFERLENGTH;
m_cursorX = 0;
m_active = false;
m_comLength = 0;
m_candleNum = -1;
m_AlignType = _XFONT_ALIGNTYPE_LEFT;
m_ShowWindow = FALSE;
m_NoFocusedDraw = FALSE;
m_ShowWindowRectangle = FALSE;
m_WindowPosition.x = m_WindowPosition.y = 0;
m_WindowSize.cx = 256;
m_WindowSize.cy = 12;
m_TextColor = _XSC_DEFAULT;
m_pReturnKeyCallbackFunction = NULL;
m_pEscapeKeyCallbackFunction = NULL;
m_pTabKeyCallbackFunction = NULL;
m_pUpArrowKeyCallbackFunction = NULL;
m_pDownArrowKeyCallbackFunction = NULL;
m_pLeftArrowKeyCallbackFunction = NULL;
m_pRightArrowKeyCallbackFunction = NULL;
m_pBackSpaceKeyCallbackFunction = NULL;
m_pDataChangeCallbackFunction = NULL;
m_pNextIMEContainer = NULL;
m_PasswordEdit = FALSE;
m_bNewLine = FALSE;
m_HorizScrolling = FALSE;
m_ScrollPosition = 0;
memset( m_text, 0, sizeof(TCHAR) * (MAX_IMEBUFFERLENGTH + 1) );
memset( m_candleText, 0, sizeof(TCHAR) * MAX_CANDLE_LENGTH * MAX_CANDLE_COUNT );
memset( m_comText, 0, sizeof(TCHAR) * (MAX_IMEBUFFERLENGTH + 1) );
}
void _XIMEContainer::ClearBuffer( void )
{
memset( m_text, 0, sizeof(TCHAR) * (MAX_IMEBUFFERLENGTH + 1) );
memset( m_candleText, 0, sizeof(TCHAR) * MAX_CANDLE_LENGTH * MAX_CANDLE_COUNT );
memset( m_comText, 0, sizeof(TCHAR) * (MAX_IMEBUFFERLENGTH + 1) );
m_length = 0;
m_cursorX = 0;
m_comLength = 0;
m_candleNum = -1;
m_ScrollPosition = 0;
}
void _XIMEContainer::SetFocus( void )
{
_XIMEKERNEL.SetFocus( this );
}
BOOL _XIMEContainer::IsFocused( void )
{
return (_XIMEKERNEL.GetIMEContainer() == this);
}
void _XIMEContainer::AddChar(TCHAR c)
{
if( !m_HorizScrolling )
{
if( g_XBaseFont.GetWidth( m_text ) > m_WindowSize.cx ) return;
}
if(m_length == m_MaxLength) return;
int rightLen = 0;
TCHAR rightStr[MAX_IMEBUFFERLENGTH];
memset( rightStr, 0, sizeof(TCHAR)*MAX_IMEBUFFERLENGTH );
rightLen = GetRightString(rightStr);
m_text[m_cursorX++] = c;
m_length++;
if(rightLen)
{
memset( m_text + m_cursorX, 0, sizeof(TCHAR) * (MAX_IMEBUFFERLENGTH - m_cursorX ) );
strncpy(m_text + m_cursorX, rightStr ,rightLen);
}
m_text[m_length] = NULL;
if( m_pDataChangeCallbackFunction )
{
m_pDataChangeCallbackFunction( this );
}
if( m_HorizScrolling )
{
int leftLen = 0;
TCHAR leftStr[MAX_IMEBUFFERLENGTH];
memset( leftStr, 0, sizeof(TCHAR)*MAX_IMEBUFFERLENGTH );
leftLen = GetLeftString(leftStr);
if( leftLen > 0 )
{
int leftWidth = g_XBaseFont.GetWidth( leftStr );
if( leftWidth > m_WindowSize.cx )
m_ScrollPosition = leftWidth - m_WindowSize.cx;
}
}
}
void _XIMEContainer::AddWord(TCHAR *w)
{
if( !m_HorizScrolling )
{
if( g_XBaseFont.GetWidth( m_text ) > m_WindowSize.cx ) return;
}
if(m_length + 2 > m_MaxLength) return;
TCHAR rightStr[MAX_IMEBUFFERLENGTH];
memset( rightStr, 0, sizeof(TCHAR)*MAX_IMEBUFFERLENGTH );
int rightLen = GetRightString(rightStr);
m_text[m_cursorX++] = *w;
m_text[m_cursorX++] = *(w+1);
m_length+= 2;
if(rightLen)
{
memset( m_text + m_cursorX, 0, sizeof(TCHAR) * (MAX_IMEBUFFERLENGTH - m_cursorX ) );
strncpy(m_text + m_cursorX, rightStr ,rightLen);
}
m_text[m_length] = NULL;
if( m_pDataChangeCallbackFunction )
{
m_pDataChangeCallbackFunction( this );
}
if( m_HorizScrolling )
{
int leftLen = 0;
TCHAR leftStr[MAX_IMEBUFFERLENGTH];
memset( leftStr, 0, sizeof(TCHAR)*MAX_IMEBUFFERLENGTH );
leftLen = GetLeftString(leftStr);
if( leftLen > 0 )
{
int leftWidth = g_XBaseFont.GetWidth( leftStr );
if( leftWidth > m_WindowSize.cx )
m_ScrollPosition = leftWidth - m_WindowSize.cx;
}
}
}
void _XIMEContainer::AddString(TCHAR *string,int length)
{
TCHAR *tmp = string;
for(int i = 0;i<length;i++)
{
if(IsDBCSLeadByte(*tmp))
{
AddWord(tmp++);
i++; tmp++;
}
else
{
AddChar(*tmp);
tmp++;
}
}
}
void _XIMEContainer::ResetCandleList( void )
{
memset( m_candleText, 0, sizeof(TCHAR) * MAX_CANDLE_LENGTH * MAX_CANDLE_COUNT );
m_candleNum = 0;
m_candleLength = 0;
}
void _XIMEContainer::SetCandleText(int candleindex, const TCHAR *candles)
{
if( candleindex >= MAX_CANDLE_COUNT ) return;
memset( m_candleText[candleindex], 0, sizeof(TCHAR) * MAX_CANDLE_LENGTH );
strncpy( m_candleText[candleindex],candles,strlen(candles) );
}
void _XIMEContainer::SetCandleNum(int num)
{
m_candleNum = num;
}
void _XIMEContainer::SetCandleLength(int len)
{
m_candleLength = len;
}
void _XIMEContainer::ProcessDelKey( void )
{
if(m_cursorX == m_length)
return;
TCHAR rightStr[MAX_IMEBUFFERLENGTH];
memset( rightStr, 0, sizeof(TCHAR)*MAX_IMEBUFFERLENGTH );
int rightLen = GetRightString(rightStr);
int check = 1;
if(IsDBCSLeadByte(m_text[m_cursorX]))
{
m_length--;
check += 1;
}
m_length--;
if( m_length < 0 )
{
m_length = 0;
}
if( m_cursorX < 0 )
{
m_cursorX = 0;
}
m_text[m_cursorX] = 0;
if(rightLen > 0 && (rightLen - check) > 0 )
strncpy(m_text + m_cursorX, rightStr + check,rightLen - check);
m_text[m_length] = 0;
if( m_pDataChangeCallbackFunction )
{
m_pDataChangeCallbackFunction( this );
}
}
void _XIMEContainer::ProcessHomeKey( void )
{
m_cursorX = 0;
if( m_HorizScrolling )
{
int leftLen = 0;
TCHAR leftStr[MAX_IMEBUFFERLENGTH];
memset( leftStr, 0, sizeof(TCHAR)*MAX_IMEBUFFERLENGTH );
leftLen = GetLeftString(leftStr);
if( leftLen > 0 )
{
int leftWidth = g_XBaseFont.GetWidth( leftStr );
if( leftWidth < m_ScrollPosition )
m_ScrollPosition = leftWidth;
}
else
{
m_ScrollPosition = 0;
}
}
}
void _XIMEContainer::ProcessEndKey( void )
{
m_cursorX = m_length;
if( m_HorizScrolling )
{
int leftLen = 0;
TCHAR leftStr[MAX_IMEBUFFERLENGTH];
memset( leftStr, 0, sizeof(TCHAR)*MAX_IMEBUFFERLENGTH );
leftLen = GetLeftString(leftStr);
if( leftLen > 0 )
{
int leftWidth = g_XBaseFont.GetWidth( leftStr );
if( leftWidth > m_WindowSize.cx )
m_ScrollPosition = leftWidth - m_WindowSize.cx;
}
}
}
void _XIMEContainer::ProcessBackSpaceKey( void )
{
if(m_cursorX <= 0)
{
m_cursorX = 0;
m_bNewLine = TRUE;
return ;
}
TCHAR rightStr[MAX_IMEBUFFERLENGTH];
memset( rightStr, 0, sizeof(TCHAR)*MAX_IMEBUFFERLENGTH );
int rightLen = GetRightString(rightStr);
if( IsDBCS( m_text, --m_cursorX ) )
{
--m_cursorX;
--m_length;
}
--m_length;
if( m_length < 0 )
{
m_length = 0;
m_cursorX = 0;
m_ScrollPosition = 0;
memset( m_text, 0, sizeof(TCHAR) * MAX_IMEBUFFERLENGTH );
if( m_pDataChangeCallbackFunction )
{
m_pDataChangeCallbackFunction( this );
}
return;
}
if( m_cursorX < 0 )
{
m_cursorX = 0;
}
m_text[m_cursorX] = 0;
if(rightLen > 0)
{
memset( m_text + m_cursorX, 0, sizeof(TCHAR) * (MAX_IMEBUFFERLENGTH - m_cursorX ) );
strncpy(m_text + m_cursorX, rightStr ,rightLen);
}
memset( m_text + m_length, 0, sizeof(TCHAR) * (MAX_IMEBUFFERLENGTH - m_length ) );
if( m_pDataChangeCallbackFunction )
{
m_pDataChangeCallbackFunction( this );
}
if( m_HorizScrolling )
{
int leftLen = 0;
TCHAR leftStr[MAX_IMEBUFFERLENGTH];
memset( leftStr, 0, sizeof(TCHAR)*MAX_IMEBUFFERLENGTH );
leftLen = GetLeftString(leftStr);
if( leftLen > 0 )
{
int leftWidth = g_XBaseFont.GetWidth( leftStr );
if( leftWidth < m_ScrollPosition )
m_ScrollPosition = leftWidth;
}
else
{
m_ScrollPosition = 0;
}
}
}
void _XIMEContainer::ProcessEscapeKey( void )
{
}
void _XIMEContainer::ProcessTabKey( void )
{
if( m_pNextIMEContainer )
{
_XIMEKERNEL.SetFocus( m_pNextIMEContainer );
}
else if( m_pTabKeyCallbackFunction )
{
m_pTabKeyCallbackFunction( this );
}
}
void _XIMEContainer::ProcessLeftKey( void )
{
if(m_cursorX == 0)
{
m_bNewLine = TRUE;
return;
}
if(IsDBCSLeadByte(m_text[--m_cursorX]))
{
--m_cursorX;
}
if( m_HorizScrolling )
{
int leftLen = 0;
TCHAR leftStr[MAX_IMEBUFFERLENGTH];
memset( leftStr, 0, sizeof(TCHAR)*MAX_IMEBUFFERLENGTH );
leftLen = GetLeftString(leftStr);
if( leftLen > 0 )
{
int leftWidth = g_XBaseFont.GetWidth( leftStr );
if( leftWidth < m_ScrollPosition )
m_ScrollPosition = leftWidth;
}
else
{
m_ScrollPosition = 0;
}
}
}
void _XIMEContainer::ProcessRightKey( void )
{
if(m_cursorX == m_length)
{
m_bNewLine = TRUE;
return;
}
if(IsDBCSLeadByte(m_text[m_cursorX++]))
{
m_cursorX++;
}
if( m_HorizScrolling )
{
int leftLen = 0;
TCHAR leftStr[MAX_IMEBUFFERLENGTH];
memset( leftStr, 0, sizeof(TCHAR)*MAX_IMEBUFFERLENGTH );
leftLen = GetLeftString(leftStr);
if( leftLen > 0 )
{
int leftWidth = g_XBaseFont.GetWidth( leftStr );
if( leftWidth > m_WindowSize.cx )
m_ScrollPosition = leftWidth - m_WindowSize.cx;
}
}
}
void _XIMEContainer::CandleLeft( void )
{
if(!IsCandle()) return;
if(m_candleNum == 0) return;
m_candleNum -= MAX_CANDLE_VIEWCOUNT;
UpdateCandleList();
}
void _XIMEContainer::CandleRight( void )
{
if(!IsCandle())
return;
if(m_candleNum + MAX_CANDLE_VIEWCOUNT >= m_candleLength)
return;
m_candleNum += MAX_CANDLE_VIEWCOUNT;
UpdateCandleList();
}
void _XIMEContainer::UpdateCandleList( void )
{
if( g_IMEWindow.m_pListBox )
{
g_IMEWindow.m_pListBox->DeleteAllItem();
if( m_candleNum > -1 )
{
TCHAR candlestring[MAX_CANDLE_LENGTH];
memset( candlestring, 0, sizeof(TCHAR) * MAX_CANDLE_LENGTH );
for( int i = m_candleNum; i < m_candleNum+MAX_CANDLE_VIEWCOUNT; i++ )
{
if( !strlen(m_candleText[i]) ) break;
sprintf( candlestring, "%2d %s", i-m_candleNum+1, m_candleText[i] );
g_IMEWindow.m_pListBox->InsertListItem( candlestring, _XSC_DEFAULT );
}
}
}
}
int _XIMEContainer::GetLeftString(TCHAR *target)
{
if(m_cursorX == 0)
return 0;
strncpy(target, m_text, m_cursorX);
return m_cursorX;
}
int _XIMEContainer::GetRightString(TCHAR *target)
{
if(m_cursorX == m_length)
return 0;
strncpy(target,m_text + m_cursorX, m_length - m_cursorX);
return m_length - m_cursorX;
}
void _XIMEContainer::SetCursorX( int cursorx )
{
if( cursorx < m_length )
m_cursorX = cursorx;
else
m_cursorX = m_length;
}
void _XIMEContainer::SetComText(TCHAR *text,int length)
{
strncpy(m_comText,text, length);
m_comText[length] = 0;
m_comLength = length;
}
void _XIMEContainer::SetComTextBlank( void )
{
m_comText[0] = 0;
m_comLength = 0;
}
int _XIMEContainer::GetMaxLength( void )
{
return m_MaxLength;
}
TCHAR* _XIMEContainer::GetText( void )
{
return m_text;
}
TCHAR* _XIMEContainer::GetComText( void )
{
return m_comText;
}
int _XIMEContainer::GetComTextlength( void )
{
return m_comLength;
}
TCHAR* _XIMEContainer::GetCandle( int candleindex )
{
if( candleindex >= m_candleNum ) return NULL;
return m_candleText[candleindex];
}
int _XIMEContainer::GetCandleTextlength( void )
{
return m_candleLength;
}
int _XIMEContainer::GetLength( void )
{
return m_length;
}
int _XIMEContainer::GetCursorX( void )
{
return m_cursorX;
}
bool _XIMEContainer::GetAvtive( void )
{
return m_active;
}
bool _XIMEContainer::GetNewLine( void )
{
return m_bNewLine;
}
bool _XIMEContainer::GetFocus( void )
{
return ( _XIMEKERNEL.GetIMEContainer() == this );
}
bool _XIMEContainer::IsCandle( void )
{
if(m_candleNum == -1)
return false;
return true;
}
void _XIMEContainer::MoveWindow( int X, int Y )
{
m_WindowPosition.x = X;
m_WindowPosition.y = Y;
}
void _XIMEContainer::ResizeWindow( int width, int height )
{
m_WindowSize.cx = width;
m_WindowSize.cy = height;
}
void _XIMEContainer::Draw( _XGUIObject*& pfocusobject )
{
if( !m_ShowWindow && !m_NoFocusedDraw ) return;
TCHAR leftstring[MAX_IMEBUFFERLENGTH];
TCHAR rightstring[MAX_IMEBUFFERLENGTH];
TCHAR textbuffer[MAX_IMEBUFFERLENGTH];
memset( leftstring, 0, sizeof(TCHAR)*MAX_IMEBUFFERLENGTH );
memset( rightstring, 0, sizeof(TCHAR)*MAX_IMEBUFFERLENGTH );
memset( textbuffer, 0, sizeof(TCHAR)*MAX_IMEBUFFERLENGTH );
GetLeftString(leftstring);
GetRightString(rightstring);
sprintf( textbuffer, "%s%s%s", leftstring, m_comText, rightstring );
if( m_ShowWindowRectangle )
{
_XDrawRectAngle( m_WindowPosition.x - 2, m_WindowPosition.y-2, m_WindowPosition.x+m_WindowSize.cx+1,
m_WindowPosition.y+m_WindowSize.cy+1, 0.0f, D3DCOLOR_ARGB(255,20,20,20) );
}
if( m_PasswordEdit )
{
TCHAR pwString[_XDEF_MAXPWSTRINGSIZE];
memset( pwString, '*', _XDEF_MAXPWSTRINGSIZE-1 );
pwString[_XDEF_MAXPWSTRINGSIZE-1] = '\0';
pwString[ strlen( textbuffer ) ] = '\0';
g_XBaseFont.SetColor(m_TextColor);
int strwidth = g_XBaseFont.GetWidth( textbuffer );
int alignpt;
switch( m_AlignType )
{
default:
case _XFONT_ALIGNTYPE_LEFT :
alignpt = 0;
g_XBaseFont.Puts( m_WindowPosition.x, m_WindowPosition.y, pwString );
break;
case _XFONT_ALIGNTYPE_RIGHT :
alignpt = m_WindowSize.cx - strwidth;
g_XBaseFont.Puts( m_WindowPosition.x+alignpt, m_WindowPosition.y, pwString );
break;
case _XFONT_ALIGNTYPE_CENTER :
alignpt = (m_WindowSize.cx>>1) - (strwidth>>1);
g_XBaseFont.Puts( m_WindowPosition.x+alignpt, m_WindowPosition.y, pwString );
break;
}
if( m_ShowWindow || !m_NoFocusedDraw )
{
if( (gnFPS>>1) < gnFrameCounter && _XIMEKERNEL.GetIMEContainer() == this )
{
int length = strlen( leftstring );
int asterisksize = g_XBaseFont.GetWidth( "*" );
g_XBaseFont.SetColor(D3DCOLOR_ARGB( 255, 215, 235, 188 ));
g_XBaseFont.Puts( m_WindowPosition.x+length*asterisksize+alignpt, m_WindowPosition.y, _XDEF_CARETTYPE );
}
}
g_XBaseFont.Flush();
}
else
{
g_XBaseFont.SetColor(m_TextColor);
int strwidth = g_XBaseFont.GetWidth( textbuffer );
if(m_HorizScrolling)
{
int alignpt;
int leftsize = g_XBaseFont.GetWidth( leftstring );
g_XBaseFont.SetClippingArea( m_WindowPosition.x, m_WindowPosition.y, m_WindowPosition.x+m_WindowSize.cx-1, m_WindowPosition.y+m_WindowSize.cy-1 );
if( strwidth > m_WindowSize.cx )
{
alignpt = -m_ScrollPosition;
g_XBaseFont.Puts( m_WindowPosition.x+alignpt, m_WindowPosition.y, textbuffer );
}
else
{
alignpt = 0;
g_XBaseFont.Puts( m_WindowPosition.x, m_WindowPosition.y, textbuffer );
}
if( m_ShowWindow || !m_NoFocusedDraw )
{
if( (gnFPS>>1) < gnFrameCounter && _XIMEKERNEL.GetIMEContainer() == this )
{
g_XBaseFont.SetColor(D3DCOLOR_ARGB( 255, 215, 235, 188 ));
{
g_XBaseFont.Puts( m_WindowPosition.x+leftsize+alignpt, m_WindowPosition.y, _XDEF_CARETTYPE );
}
}
}
g_XBaseFont.Flush();
g_XBaseFont.DisableClippingArea();
}
else
{
int alignpt;
switch( m_AlignType )
{
default:
case _XFONT_ALIGNTYPE_LEFT :
alignpt = 0;
g_XBaseFont.Puts( m_WindowPosition.x, m_WindowPosition.y, textbuffer );
break;
case _XFONT_ALIGNTYPE_RIGHT :
alignpt = m_WindowSize.cx - strwidth;
g_XBaseFont.Puts( m_WindowPosition.x+alignpt, m_WindowPosition.y, textbuffer );
break;
case _XFONT_ALIGNTYPE_CENTER :
alignpt = (m_WindowSize.cx>>1) - (strwidth>>1);
g_XBaseFont.Puts( m_WindowPosition.x+alignpt, m_WindowPosition.y, textbuffer );
break;
}
if( m_ShowWindow || !m_NoFocusedDraw )
{
if( (gnFPS>>1) < gnFrameCounter && _XIMEKERNEL.GetIMEContainer() == this )
{
int leftsize = g_XBaseFont.GetWidth( leftstring );
g_XBaseFont.SetColor(D3DCOLOR_ARGB( 255, 215, 235, 188 ));
g_XBaseFont.Puts( m_WindowPosition.x+leftsize+alignpt, m_WindowPosition.y, _XDEF_CARETTYPE );
}
}
g_XBaseFont.Flush();
}
}
}
BOOL _XIMEContainer::CheckMousePosition( void )
{
if( !m_ShowWindow ) return FALSE;
ScrnPos* scrnpos = gpInput->GetMouseVirScreenPos();
if( scrnpos )
{
return gpInput->CheckMousePos( m_WindowPosition.x, m_WindowPosition.y, m_WindowPosition.x + m_WindowSize.cx, m_WindowPosition.y + m_WindowSize.cy );
}
return FALSE;
}
_XIMEKernel * _XIMEKernel::ms_pThis;
_XIMEKernel& _XIMEKernel::GetInstance( void )
{
assert(ms_pThis!=NULL && "_XIMEKernel :: not initialized ime kernel");
return *ms_pThis;
}
_XIMEKernel::_XIMEKernel()
{
ms_pThis=this;
m_pIMEContainer = NULL;
ResetCombinationBuffer();
}
_XIMEKernel::~_XIMEKernel()
{
}
_XIMEContainer* _XIMEKernel::GetIMEContainer( void )
{
return m_pIMEContainer;
}
bool _XIMEKernel::GetComposition(HWND hWnd, WPARAM wparam, LPARAM lparam)
{
assert(m_pIMEContainer != NULL && "Invalid pointer : _XIMEContainer");
HIMC m_hIMC = ImmGetContext(hWnd);
POINT pt;
pt.x = gnWidth;
pt.y = gnHeight;
ImmSetStatusWindowPos(m_hIMC, &pt);
COMPOSITIONFORM CompForm;
CANDIDATEFORM CandForm;
CompForm.dwStyle = CFS_POINT;
CompForm.ptCurrentPos.x = 3200;
CompForm.ptCurrentPos.y = 3200;
ImmSetCompositionWindow(m_hIMC, &CompForm);
CandForm.dwIndex = 0;
CandForm.dwStyle = CFS_CANDIDATEPOS;
CandForm.ptCurrentPos.x = 3200;
CandForm.ptCurrentPos.y = 2000;
ImmSetCandidateWindow(m_hIMC, &CandForm);
if(lparam & GCS_RESULTSTR)
{
TCHAR szTmp[21];
memset( szTmp, 0, 21 );
int len = ImmGetCompositionString(m_hIMC, GCS_RESULTSTR, NULL, 0);
if(len == 0) return false;
ImmGetCompositionString(m_hIMC, GCS_RESULTSTR, szTmp, len);
if( m_pIMEContainer )
{
m_pIMEContainer->AddString(szTmp,len);
m_pIMEContainer->SetComText("",0);
}
}
if(
lparam & GCS_COMPSTR)
{
TCHAR szTmp[21];
memset( szTmp, 0, 21 );
if( m_pIMEContainer )
{
int len = ImmGetCompositionString(m_hIMC, GCS_COMPSTR, NULL, 0);
if(len + m_pIMEContainer->GetLength() > m_pIMEContainer->GetMaxLength())
{
ImmNotifyIME(m_hIMC, NI_COMPOSITIONSTR, CPS_CANCEL, 0);
m_pIMEContainer->SetComText("",0);
return true;
}
ImmGetCompositionString(m_hIMC, GCS_COMPSTR, szTmp, len);
m_pIMEContainer->SetComText(szTmp, len);
}
}
if( !m_pIMEContainer )
{
ImmNotifyIME(m_hIMC, NI_COMPOSITIONSTR, CPS_CANCEL, 0);
}
ImmReleaseContext(hWnd, m_hIMC);
return true;
}
bool _XIMEKernel::GetMsg(HWND hWnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
switch(msg)
{
case WM_CHAR:
return GetChar(wparam,lparam);
break;
case WM_KEYDOWN:
return GetKey(wparam,lparam);
break;
case WM_KEYUP:
return false;
break;
case WM_IME_NOTIFY:
return GetCandle(hWnd,wparam,lparam);
case WM_IME_COMPOSITION:
return GetComposition(hWnd,wparam, lparam);
}
return false;
}
bool _XIMEKernel::GetKey(WPARAM wparam, LPARAM lparam)
{
if( !m_pIMEContainer ) return false;
switch (wparam){
case VK_LEFT:
m_pIMEContainer->ProcessLeftKey();
if( m_pIMEContainer->GetNewLine() )
{
if( m_pIMEContainer->GetLeftArrowKeyCallBack() )
{
m_pIMEContainer->GetLeftArrowKeyCallBack()(m_pIMEContainer);
}
m_pIMEContainer->SetNewLine( FALSE );
}
return true;
case VK_RIGHT:
m_pIMEContainer->ProcessRightKey();
if( m_pIMEContainer->GetNewLine() )
{
if( m_pIMEContainer->GetRightArrowKeyCallBack() )
{
m_pIMEContainer->GetRightArrowKeyCallBack()(m_pIMEContainer);
}
m_pIMEContainer->SetNewLine( FALSE );
}
return true;
case VK_DELETE:
m_pIMEContainer->ProcessDelKey();
return true;
case VK_HOME:
m_pIMEContainer->ProcessHomeKey();
return true;
case VK_END:
m_pIMEContainer->ProcessEndKey();
return true;
case VK_RETURN:
if( m_pIMEContainer->GetReturnKeyCallBack() )
{
m_pIMEContainer->GetReturnKeyCallBack()(m_pIMEContainer);
}
return true;
case VK_UP:
if( m_pIMEContainer->GetUpArrowKeyCallBack() )
{
m_pIMEContainer->GetUpArrowKeyCallBack()(m_pIMEContainer);
}
return true;
case VK_DOWN:
if( m_pIMEContainer->GetDownArrowKeyCallBack() )
{
m_pIMEContainer->GetDownArrowKeyCallBack()(m_pIMEContainer);
}
return true;
case VK_ESCAPE:
if( m_pIMEContainer->GetEscapeKeyCallBack() )
{
m_pIMEContainer->GetEscapeKeyCallBack()(m_pIMEContainer);
}
return true;
case VK_PROCESSKEY:
if( g_LanguageType == _XLANGUAGE_TYPE_CHINESE )
{
if(lparam == 0x01490001)
{
m_pIMEContainer->CandleLeft();
}
else if(lparam == 0x01510001)
{
m_pIMEContainer->CandleRight();
}
}
else
{
if(lparam == 0x14B0001)
{
m_pIMEContainer->CandleLeft();
}
else if(lparam == 0x14D0001)
{
m_pIMEContainer->CandleRight();
}
}
return true;
}
return false;
}
bool _XIMEKernel::GetCandle(HWND hWnd, WPARAM wparam, LPARAM lparam)
{
HIMC m_hIMC = ImmGetContext(hWnd);
DWORD dwBufLen;
LPCANDIDATELIST m_CandList;
LPCANDIDATELIST lpCandList;
int CanNum;
switch (wparam)
{
case IMN_OPENCANDIDATE:
{
if((dwBufLen = ImmGetCandidateList(m_hIMC, 0, NULL, 0)) == 0) break;
m_CandList = (LPCANDIDATELIST)new TCHAR[dwBufLen];
lpCandList = m_CandList;
ImmGetCandidateList(m_hIMC, 0, lpCandList, dwBufLen);
CanNum = lpCandList->dwCount;
if(m_pIMEContainer)
{
m_pIMEContainer->ResetCandleList();
m_pIMEContainer->SetCandleNum(0);
m_pIMEContainer->SetCandleLength(CanNum);
for( int i = 0; i < CanNum; i++ )
{
m_pIMEContainer->SetCandleText( i, (LPSTR)(lpCandList) + lpCandList->dwOffset[i] );
}
m_pIMEContainer->UpdateCandleList();
POINT pt = m_pIMEContainer->GetWindowPosition();
SIZE sz = m_pIMEContainer->GetWindowSize();
g_IMEWindow.MoveWindow( pt.x + sz.cx, pt.y );
g_IMEWindow.ShowWindow( TRUE );
pt.x = gnWidth;
pt.y = gnHeight;
ImmSetStatusWindowPos(m_hIMC, &pt);
COMPOSITIONFORM CompForm;
CANDIDATEFORM CandForm;
CompForm.dwStyle = CFS_POINT;
CompForm.ptCurrentPos.x = 3200;
CompForm.ptCurrentPos.y = 3200;
ImmSetCompositionWindow(m_hIMC, &CompForm);
CandForm.dwIndex = 0;
CandForm.dwStyle = CFS_CANDIDATEPOS;
CandForm.ptCurrentPos.x = 3200;
CandForm.ptCurrentPos.y = 2000;
ImmSetCandidateWindow(m_hIMC, &CandForm);
}
delete m_CandList;
}
break;
case IMN_CHANGECANDIDATE:
{
if(m_pIMEContainer)
{
m_pIMEContainer->UpdateCandleList();
POINT pt = m_pIMEContainer->GetWindowPosition();
SIZE sz = m_pIMEContainer->GetWindowSize();
g_IMEWindow.MoveWindow( pt.x + sz.cx, pt.y );
g_IMEWindow.ShowWindow( TRUE );
}
POINT pt;
pt.x = gnWidth;
pt.y = gnHeight;
ImmSetStatusWindowPos(m_hIMC, &pt);
COMPOSITIONFORM CompForm;
CANDIDATEFORM CandForm;
CompForm.dwStyle = CFS_POINT;
CompForm.ptCurrentPos.x = 3200;
CompForm.ptCurrentPos.y = 3200;
ImmSetCompositionWindow(m_hIMC, &CompForm);
CandForm.dwIndex = 0;
CandForm.dwStyle = CFS_CANDIDATEPOS;
CandForm.ptCurrentPos.x = 3200;
CandForm.ptCurrentPos.y = 3200;
ImmSetCandidateWindow(m_hIMC, &CandForm);
}
break;
case IMN_CLOSECANDIDATE:
if(m_pIMEContainer)
{
m_pIMEContainer->SetCandleLength(0);
m_pIMEContainer->SetCandleNum(-1);
}
g_IMEWindow.ShowWindow( FALSE );
if( g_IMEWindow.m_pListBox )
g_IMEWindow.m_pListBox->DeleteAllItem();
break;
}
ImmReleaseContext(hWnd, m_hIMC);
return true;
}
bool _XIMEKernel::GetChar(WPARAM wparam, LPARAM lparam)
{
if( gpInput->CheckKeyPress(DIK_LCONTROL) || gpInput->CheckKeyPress(DIK_LMENU) ) return false;
if( !m_pIMEContainer ) return false;
switch (wparam)
{
case VK_ESCAPE:
if( m_pIMEContainer )
m_pIMEContainer->ProcessEscapeKey();
return true;
case VK_TAB:
if( m_pIMEContainer )
m_pIMEContainer->ProcessTabKey();
return true;
case VK_BACK:
if( m_pIMEContainer )
{
m_pIMEContainer->ProcessBackSpaceKey();
if( m_pIMEContainer->GetNewLine() )
{
if( m_pIMEContainer->GetBackSpaceKeyCallBack() )
{
m_pIMEContainer->GetBackSpaceKeyCallBack()(m_pIMEContainer);
}
m_pIMEContainer->SetNewLine( FALSE );
}
}
return true;
case VK_RETURN:
return true;
default:
if(IsDBCSLeadByte((BYTE)wparam)) return true;
m_pIMEContainer->AddChar((TCHAR)wparam);
return true;
}
return false;
}
void _XIMEKernel::SetFocus(_XIMEContainer* imecontainer)
{
m_pIMEContainer = imecontainer;
if(m_pIMEContainer)
{
if( m_pIMEContainer->GetPasswordMode() )
{
HIMC hIMC = ImmGetContext(gHWnd);
if( hIMC )
{
ImmSetConversionStatus( hIMC, IME_CMODE_ALPHANUMERIC, IME_SMODE_NONE );
ImmReleaseContext(gHWnd, hIMC);
}
}
m_pIMEContainer->ShowWindow(TRUE);
}
}
void _XIMEKernel::ResetCombinationBuffer( void )
{
HIMC m_hIMC = ImmGetContext(gHWnd);
if(m_hIMC)
{
ImmNotifyIME(m_hIMC, NI_COMPOSITIONSTR, CPS_CANCEL, 0);
ImmReleaseContext(gHWnd, m_hIMC);
if( m_pIMEContainer )
m_pIMEContainer->SetComText("",0);
}
}
| C++ |
#if !defined(_XIME_H_)
#define _XIME_H_
#if _MSC_VER > 1000
#pragma once
#endif
#include "IMM.h"
class _XIMEContainer;
typedef void (__stdcall *_XIMESpecialKeyCallback)( _XIMEContainer* pIMEContainer );
typedef BOOL (__stdcall *_XIMEStatusCallback)( _XIMEContainer* pIMEContainer );
#define MAX_IMEBUFFERLENGTH 256
#define MAX_MULTILINE_COUNT 256
#define MAX_MULTILINE_LENGTH 256
#define MAX_CANDLE_COUNT 256
#define MAX_CANDLE_LENGTH 32
#define MAX_CANDLE_VIEWCOUNT 9
#define _XDEF_CARETTYPE "_"
#define _XDEF_MAXPWSTRINGSIZE 32
class _XIMEKernel
{
public:
static _XIMEKernel& GetInstance( void );
_XIMEKernel();
~_XIMEKernel();
_XIMEContainer* GetIMEContainer( void );
void SetFocus(_XIMEContainer* imecontainer);
void Clear( void );
void ResetCombinationBuffer( void );
bool GetMsg(HWND hWnd, UINT msg,WPARAM wparam, LPARAM lparam);
bool GetChar(WPARAM wparam, LPARAM lparam);
bool GetKey(WPARAM wparam, LPARAM lparam);
bool GetCandle(HWND hWnd, WPARAM wparam, LPARAM lparam);
bool GetComposition(HWND hWnd, WPARAM wparam, LPARAM lparam);
private:
_XIMEContainer* m_pIMEContainer;
static _XIMEKernel* ms_pThis;
};
#define _XIMEKERNEL _XIMEKernel::GetInstance()
class _XIMEContainer
{
private:
public:
_XIMEContainer();
~_XIMEContainer();
void ResetContainer( void );
void ClearBuffer( void );
void SetFocus( void );
BOOL IsFocused( void );
void AddChar(TCHAR c);
void AddWord(TCHAR *w);
void AddString(TCHAR *string,int length);
void ProcessDelKey( void );
void ProcessHomeKey( void );
void ProcessEndKey( void );
void ProcessBackSpaceKey( void );
void ProcessLeftKey( void );
void ProcessRightKey( void );
void ProcessEscapeKey( void );
void ProcessTabKey( void );
void CandleLeft( void );
void CandleRight( void );
void UpdateCandleList( void );
void ResetCandleList( void );
int GetMaxLength( void );
TCHAR* GetText( void );
TCHAR* GetComText( void );
int GetComTextlength( void );
TCHAR* GetCandle( int candleindex );
int GetCandleTextlength( void );
int GetCandleScrollIndex( void ){ return m_candleNum; }
int GetLength( void );
int GetCursorX( void );
bool GetAvtive( void );
bool GetFocus( void );
bool IsCandle( void );
bool GetNewLine( void );
void SetComText(TCHAR *text,int length);
void SetComTextBlank( void );
void SetCandleText(int candleindex, const TCHAR *candles);
void SetCandleNum(int num);
void SetCandleLength(int len);
void SetCursorX( int cursorx );
void SetMaxLength( int length )
{
if( length > MAX_IMEBUFFERLENGTH ) m_MaxLength = MAX_IMEBUFFERLENGTH;
else m_MaxLength = length;
}
void SetNewLine( bool newline ){ m_bNewLine = newline; }
void SetHorizScrollMode( BOOL scroll )
{
m_HorizScrolling = scroll;
}
BOOL CheckMousePosition( void );
private:
BOOL m_ShowWindow;
BOOL m_NoFocusedDraw;
BOOL m_ShowWindowRectangle;
BOOL m_PasswordEdit;
POINT m_WindowPosition;
SIZE m_WindowSize;
D3DCOLOR m_TextColor;
DWORD m_CommandID;
BOOL m_HorizScrolling;
int m_ScrollPosition;
_XIMEContainer* m_pNextIMEContainer;
_XIMESpecialKeyCallback m_pReturnKeyCallbackFunction;
_XIMESpecialKeyCallback m_pEscapeKeyCallbackFunction;
_XIMESpecialKeyCallback m_pTabKeyCallbackFunction;
_XIMESpecialKeyCallback m_pUpArrowKeyCallbackFunction;
_XIMESpecialKeyCallback m_pDownArrowKeyCallbackFunction;
_XIMESpecialKeyCallback m_pLeftArrowKeyCallbackFunction;
_XIMESpecialKeyCallback m_pRightArrowKeyCallbackFunction;
_XIMESpecialKeyCallback m_pBackSpaceKeyCallbackFunction;
_XIMEStatusCallback m_pDataChangeCallbackFunction;
public:
void ShowWindow( BOOL show )
{
m_ShowWindow = show;
if( !m_ShowWindow && (_XIMEKERNEL.GetIMEContainer() == this) )
{
_XIMEKERNEL.SetFocus( NULL );
}
}
BOOL GetShowStatus( void ){ return m_ShowWindow; }
void SetNoFocuseDraw( BOOL draw ){ m_NoFocusedDraw = draw; }
void ShowWindowRectAngle( BOOL show ){ m_ShowWindowRectangle = show; }
void MoveWindow( int X, int Y );
void ResizeWindow( int width, int height );
void Draw( _XGUIObject*& pfocusobject = g_CurrentFocusedObject );
POINT GetWindowPosition( void ){ return m_WindowPosition; }
SIZE GetWindowSize( void ){ return m_WindowSize; }
void SetAlignType( _XFONT_ALIGNTYPE aligntype ){ m_AlignType = aligntype; }
void SetTextColor( D3DCOLOR textcolor ){ m_TextColor = textcolor; }
void SetCommandID( DWORD cmdid ){ m_CommandID = cmdid; }
DWORD GetCommandID( void ){ return m_CommandID; }
_XIMEStatusCallback GetDataChangeCallBack( void )
{
return m_pDataChangeCallbackFunction;
}
void SetDataChangeCallBack( _XIMEStatusCallback pDataChangeCallback )
{
m_pDataChangeCallbackFunction = pDataChangeCallback;
}
_XIMESpecialKeyCallback GetReturnKeyCallBack( void )
{
return m_pReturnKeyCallbackFunction;
}
void SetReturnKeyCallback( _XIMESpecialKeyCallback pRetCallback )
{
m_pReturnKeyCallbackFunction = pRetCallback;
}
_XIMESpecialKeyCallback GetEscapeKeyCallBack( void )
{
return m_pEscapeKeyCallbackFunction;
}
void SetEscapeKeyCallback( _XIMESpecialKeyCallback pESCCallback )
{
m_pEscapeKeyCallbackFunction = pESCCallback;
}
_XIMESpecialKeyCallback GetTabKeyCallBack( void )
{
return m_pTabKeyCallbackFunction;
}
void SetTabKeyCallback( _XIMESpecialKeyCallback pTabCallback )
{
m_pTabKeyCallbackFunction = pTabCallback;
}
_XIMESpecialKeyCallback GetUpArrowKeyCallBack( void )
{
return m_pUpArrowKeyCallbackFunction;
}
void SetUpArrowKeyCallback( _XIMESpecialKeyCallback pUpArrowCallback )
{
m_pUpArrowKeyCallbackFunction = pUpArrowCallback;
}
_XIMESpecialKeyCallback GetDownArrowKeyCallBack( void )
{
return m_pDownArrowKeyCallbackFunction;
}
void SetDownArrowKeyCallback( _XIMESpecialKeyCallback pDownArrowCallback )
{
m_pDownArrowKeyCallbackFunction = pDownArrowCallback;
}
_XIMESpecialKeyCallback GetLeftArrowKeyCallBack( void )
{
return m_pLeftArrowKeyCallbackFunction;
}
void SetLeftArrowKeyCallback( _XIMESpecialKeyCallback pLeftArrowCallback )
{
m_pLeftArrowKeyCallbackFunction = pLeftArrowCallback;
}
_XIMESpecialKeyCallback GetRightArrowKeyCallBack( void )
{
return m_pRightArrowKeyCallbackFunction;
}
void SetRightArrowKeyCallback( _XIMESpecialKeyCallback pRightArrowCallback )
{
m_pRightArrowKeyCallbackFunction = pRightArrowCallback;
}
_XIMESpecialKeyCallback GetBackSpaceKeyCallBack( void )
{
return m_pBackSpaceKeyCallbackFunction;
}
void SetBackSpaceKeyCallback( _XIMESpecialKeyCallback pBackSpaceCallback )
{
m_pBackSpaceKeyCallbackFunction = pBackSpaceCallback;
}
void SetNextIMEContainerHandle( _XIMEContainer* nextimecontainer )
{
m_pNextIMEContainer = nextimecontainer;
}
void SetPasswordMode( BOOL mode )
{
m_PasswordEdit = mode;
}
BOOL GetPasswordMode( void )
{
return m_PasswordEdit;
}
private:
int GetLeftString(TCHAR *target);
int GetRightString(TCHAR *target);
private:
TCHAR m_text[MAX_IMEBUFFERLENGTH + 1];
int m_length;
TCHAR m_candleText[MAX_CANDLE_COUNT][MAX_CANDLE_LENGTH];
int m_candleLength;
int m_candleNum;
TCHAR m_comText[MAX_IMEBUFFERLENGTH + 1];
int m_comLength;
int m_cursorX;
bool m_bNewLine;
bool m_active;
int m_MaxLength;
};
#endif
| C++ |
extern _XTextureManager g_MainInterfaceTextureArchive;
_XWindow_IME::_XWindow_IME()
{
m_pListBox = NULL;
}
_XWindow_IME::~_XWindow_IME()
{
}
BOOL _XWindow_IME::Initialize(void)
{
int scrollresourceindex = g_MainInterfaceTextureArchive.FindResource("MI_chat_quick.tga");
_XLISTBOX_STRUCTURE listboxstructure =
{
TRUE,
{ 6, 24 },
{ 116, 128 },
0,
-1,
&g_MainInterfaceTextureArchive,
_T(" "),
14,
9,
_XLSTYLE_RIGHTSCROLLBAR,
{12, 128},
12,
22,
150,
scrollresourceindex,
scrollresourceindex,
scrollresourceindex,
scrollresourceindex,
scrollresourceindex
};
m_pListBox = new _XListBox;
m_pListBox->Create(listboxstructure);
POINT coloffset = { 2, 2 };
m_pListBox->SetColumnOffset(0, coloffset);
m_pListBox->SetColumnStyle(0, _XLCOLUMNSTYLE_STRING);
m_pListBox->SetAlignType(0, _XFONT_ALIGNTYPE_LEFT);
m_pListBox->SetColumnWidth(0, 110 );
m_pListBox->SetTrackHeight(14);
m_pListBox->SetTrackBarColor( D3DCOLOR_ARGB(64,128,128,128) );
m_pListBox->EnableSelectItem(FALSE);
m_pListBox->SetAlwaysShowScrollBarMode( FALSE );
_XVScrollBar* pScrollBar = m_pListBox->GetScrollBarObject();
if( pScrollBar )
{
_XSCRBAR_IMAGECLIPRECTSTRUCTURE cliprectstructure =
{
{ 0, 0, 12, 12 },
{ 24, 0, 36, 12 },
{ 0, 12, 12, 24 },
{ 24, 12, 36, 24 },
{ 40,157, 52, 179}
};
pScrollBar->SetClipRect( cliprectstructure );
}
InsertChildObject(m_pListBox);
return TRUE;
}
void _XWindow_IME::DestroyWindow(void)
{
_XWindow::DestroyWindow();
}
void _XWindow_IME::Draw(_XGUIObject*& pfocusobject)
{
_XWindow::Draw(pfocusobject);
if(this->m_ShowWindow)
{
DWORD blackcolor = D3DCOLOR_ARGB(255,0,0,0);
_XDrawRectAngle( m_WindowPosition.x, m_WindowPosition.y, m_WindowPosition.x+m_WindowSize.cx-1,
m_WindowPosition.y+m_WindowSize.cy-1, 0.0f, blackcolor );
_XDrawRectAngle( m_WindowPosition.x, m_WindowPosition.y, m_WindowPosition.x+m_WindowSize.cx-1,
m_WindowPosition.y+m_WindowSize.cy-1, 0.0f, D3DCOLOR_ARGB(255,32,32,32) );
_XDrawRectAngle( m_WindowPosition.x + 2, m_WindowPosition.y + 2,
m_WindowPosition.x+m_WindowSize.cx-3, m_WindowPosition.y+m_WindowSize.cy-3, 0.0f, blackcolor );
_XDrawLine2D( m_WindowPosition.x + 3, m_WindowPosition.y + 19,
m_WindowPosition.x + m_WindowSize.cx - 3, m_WindowPosition.y + 19, blackcolor,blackcolor );
_XIMEContainer* pIMEContainer = _XIMEKERNEL.GetIMEContainer();
g_XBaseFont.SetColor(_XSC_DEFAULT);
g_XBaseFont.Puts( m_WindowPosition.x + 8, m_WindowPosition.y + 6, pIMEContainer->GetComText() );
g_XBaseFont.Flush();
}
}
BOOL _XWindow_IME::Process(_XGUIObject*& pfocusobject)
{
if(!this->m_Enable)
return FALSE;
if(!this->m_ShowWindow)
return FALSE;
_XWindow::Process(pfocusobject);
return FALSE;
}
BOOL _XWindow_IME::CheckArea(void)
{
if( !m_pMyManager ) return FALSE;
if(CheckMousePosition())
{
return TRUE;
}
return FALSE;
}
void _XWindow_IME::ShowWindow(BOOL show)
{
if( show ) CheckOutside();
_XWindow::ShowWindow(show);
}
| C++ |
#ifndef _XWINDOW_IME_H_
#define _XWINDOW_IME_H_
#if _MSC_VER > 1000
#pragma once
#endif
#include "XWindow.h"
class _XListBox;
class _XWindow_IME : public _XWindow
{
public:
_XListBox* m_pListBox;
public:
_XWindow_IME();
virtual ~_XWindow_IME();
BOOL Initialize(void);
void DestroyWindow(void);
void Draw(_XGUIObject*& pfocusobject = g_CurrentFocusedObject);
BOOL Process(_XGUIObject*& pfocusobject = g_CurrentFocusedObject);
BOOL CheckArea(void);
void ShowWindow(BOOL show);
};
#endif
| C++ |
#include "../global_def.h"
itemClassTable_t g_itemClassTable[MAX_NUMBER_OF_ITEM_CLASS_TABLE];
int g_nItemClassTable;
itemTable_t g_itemTable[MAX_NUMBER_OF_ITEM_TABLE];
int g_nItemTable;
optionTable_t g_optionTable[MAX_COUNT_OPTION_TABLE];
itemGenerateTable_t g_itemGenerateTable[MAX_NUMBER_OF_ITEM_GENERATE_TABLE];
int g_nItemGenerateTable;
monsterBasicTable_t g_monsterTable[MAX_NUMBER_OF_MONSTER_TABLE];
int g_nMonsterTable;
int g_skillNumber;
skillGradeClass_t g_skillGradeClassTable[100];
genCapabilityTable_t g_genCapabilityTable;
int g_optionDescXSize;
int g_optionDescYSize;
expTable_t g_expTable[MAX_NUMBER_OF_LEVEL];
actionTable_t g_actionTable[MAX_NUMBER_OF_ACTION];
itemCraftTable_t g_itemCraftTable[MAX_NUMBER_OF_ITEM_CRAFT_TABLE];
int g_itemCraftTableNumber;
questscrollTable_t g_questscrollTable[MAX_NUMBER_OF_QUESTSCROLL_TABLE];
int g_questscrollTableNumber;
autoQuestScrollTable_t g_autoquestscrollTable[MAX_NUMBER_OF_AUTOQUESTSCROLL_TABLE];
int g_autoquestscrollTableNumber;
SummonMonster_t g_summonMonstertable[MAX_NUMBER_OF_QUESTSCROLL_TABLE];
int g_summonMonstertableNumber;
BattleRewordField_t g_BattleRewordField;
BattleRewordItem_t g_BattleRewordItem[5];
golryunManagerTable_t g_golryunManagerTable[MAX_NUMBER_OF_GOLRYUN_MANAGER_TABLE];
golryunProgressTable_t g_golryunProgressTable[MAX_NUMBER_OF_GOLRYUN_MANAGER_TABLE];
| C++ |
#include "../global_def.h"
#include "../ijl.h"
int LoadItemClassTable( char* filename )
{
BYTE *buf, *buf2;
buf2 = g_fileMng.ReadFileFromPack( filename );
buf = buf2;
tableHeader_t header;
memset( &header, 0, sizeof( tableHeader_t ) );
memcpy( &header, buf, sizeof( header ) );
buf += sizeof( header );
if( strcmp( header.id, ITEM_CLASS_TABLE_HEADER ) )
{
return( 0 );
}
if( header.version != ITEM_CLASS_TABLE_VERSION_103 )
{
return( 0 );
}
g_nItemClassTable = header.recordNumber;
for( int i = 0; i < g_nItemClassTable; i ++ )
{
memcpy( &g_itemClassTable[i], buf, sizeof( itemClassTable_t ) );
buf += sizeof( itemClassTable_t );
}
GTH_SAFE_FREE ( buf2 );
return( 1 );
}
int LoadItemTable( char* filename )
{
BYTE *buf, *buf2;
buf2 = g_fileMng.ReadFileFromPack( filename );
buf = buf2;
tableHeader_t header;
memset( &header, 0, sizeof( tableHeader_t ) );
memcpy( &header, buf, sizeof( header ) );
buf += sizeof( header );
if( strcmp( header.id, ITEM_TABLE_HEADER ) )
{
return( 0 );
}
if( header.version != ITEM_TABLE_VERSION )
{
return( 0 );
}
g_nItemTable = header.recordNumber;
int size;
memcpy( &size, buf, sizeof( size ) );
buf += sizeof( size );
if(size != sizeof(itemTable_t))
{
return( 0 );
}
int TypeSize;
memcpy( &TypeSize, buf, sizeof( TypeSize ) );
buf += sizeof( TypeSize );
char txt[256];
for( int i = 0; i < g_nItemTable; i ++ )
{
memcpy( &g_itemTable[i], buf, sizeof( itemTable_t ) );
strcpy(g_itemTable[i].name,g_LPACK.Get(LPACK_TYPE_ITEM,g_itemTable[i].NameIdx));
strcpy(txt,g_LPACK.Get(LPACK_TYPE_ITEM,g_itemTable[i].DocumentIdx));
if(strcmp(txt,"empty"))
{
strcpy(g_itemTable[i].document,txt);
}
buf += sizeof( itemTable_t );
}
GTH_SAFE_FREE ( buf2 );
return( 1 );
}
int LoadItemGenerateTable( char* filename )
{
BYTE *buf, *buf2;
buf2 = g_fileMng.ReadFileFromPack( filename );
buf = buf2;
tableHeader_t header;
memset( &header, 0, sizeof( tableHeader_t ) );
memcpy( &header, buf, sizeof( header ) );
buf += sizeof( header );
if( strcmp( header.id, ITEM_GENERATE_TABLE_HEADER ) )
{
return( 0 );
}
if( header.version != ITEM_GENERATE_TABLE_VERSION )
{
return( 0 );
}
g_nItemGenerateTable = header.recordNumber;
for( int i = 0; i < g_nItemGenerateTable; i ++ )
{
memcpy( &g_itemGenerateTable[i], buf, sizeof( itemGenerateTable_t ) );
buf += sizeof( itemGenerateTable_t );
}
GTH_SAFE_FREE ( buf2 );
return( 1 );
}
int LoadMonsterTable( char* filename )
{
BYTE *buf, *buf2;
buf2 = g_fileMng.ReadFileFromPack( filename );
buf = buf2;
tableHeader_t header;
memset( &header, 0, sizeof( tableHeader_t ) );
memcpy( &header, buf, sizeof( header ) );
buf += sizeof( header );
if( strcmp( header.id, MONSTER_TABLE_HEADER ) )
{
return( 0 );
}
if( header.version != MONSTER_TABLE_VERSION )
{
return( 0 );
}
g_nMonsterTable = header.recordNumber;
for( int i = 0; i < g_nMonsterTable; i ++ )
{
memcpy( &g_monsterTable[i], buf, sizeof( monsterBasicTable_t ) );
buf += sizeof( monsterBasicTable_t );
}
GTH_SAFE_FREE ( buf2 );
return( 1 );
}
int LoadSkillTable( char *filename )
{
return( 1 );
}
void LoadExpTableForClient( char* filename )
{
int level;
int expLevel=0;
char* token;
g_script.Load( filename );
g_script.BeginParse();
for( int i = 0; i < MAX_NUMBER_OF_LEVEL; i ++ )
memset( &g_expTable[i], 0, sizeof( expTable_t ) );
while( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == 0 ) break;
level = atoi( token );
token = g_script.GetNextToken( true );
g_expTable[expLevel].totalexp = _atoi64( token );
token = g_script.GetNextToken( true );
g_expTable[expLevel].exp = _atoi64( token );
expLevel++;
}
}
void LoadGenExpTableForClient( char* filename )
{
int level;
int genExpLevel=0;
char* token;
g_script.Load( filename );
g_script.BeginParse();
while( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == 0 ) break;
level = atoi( token );
token = g_script.GetNextToken( true );
g_expTable[genExpLevel].totalGenExp = _atoi64( token );
token = g_script.GetNextToken( true );
g_expTable[genExpLevel].genExp = _atoi64( token );
genExpLevel++;
}
}
void GetActionTableData(actionTable_t *table,int id,char* token)
{
table->id = id;
token = g_script.GetNextToken( true );
table->iconIdx = atoi( token );
token = g_script.GetNextToken( true );
table->nDescIdx = atoi( token );
token = g_script.GetNextToken( true );
table->nLPackID = atoi( token );
token = g_script.GetNextToken( true );
table->nFreeDescIdx = atoi( token );
token = g_script.GetNextToken( true );
table->nFreeLPackID = atoi( token );
}
void LoadActionTable( char *filename )
{
char* token;
#define ACTION_TABLE_VERSION 100
g_script.Load( filename );
g_script.BeginParse();
for( int i = 0; i < MAX_NUMBER_OF_ACTION; i ++ )
{
memset( &g_actionTable[i], 0, sizeof( actionTable_t ) );
g_actionTable[i].id = -1;
}
int Version =0;
while( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == 0 ) break;
if( !stricmp( token, "VERSION" ) )
{
token = g_script.GetNextToken( true );
Version = atoi( token );
}
else if( !stricmp( token, "ATTACK" ) )
{
GetActionTableData(&g_actionTable[ACTION_ATTACK],ACTION_ATTACK,token);
}
else if( !stricmp( token, "ASSIST" ) )
{
GetActionTableData(&g_actionTable[ACTION_ASSIST],ACTION_ASSIST,token);
}
else if( !stricmp( token, "FOLLOW" ) )
{
GetActionTableData(&g_actionTable[ACTION_FOLLOW],ACTION_FOLLOW,token);
}
else if( !stricmp( token, "PICKUP_ITEM" ) )
{
GetActionTableData(&g_actionTable[ACTION_PICKUP_ITEM],ACTION_PICKUP_ITEM,token);
}
else if( !stricmp( token, "EPACK_RA" ) )
{
GetActionTableData(&g_actionTable[ACTION_EPACK_RA],ACTION_EPACK_RA,token);
}
else if( !stricmp( token, "EPACK_SA" ) )
{
GetActionTableData(&g_actionTable[ACTION_EPACK_SA],ACTION_EPACK_SA,token);
}
else if( !stricmp( token, "SIT" ) )
{
GetActionTableData(&g_actionTable[ACTION_SIT],ACTION_SIT,token);
}
else if( !stricmp( token, "TRADE" ) )
{
GetActionTableData(&g_actionTable[ACTION_TRADE],ACTION_TRADE,token);
}
else if( !stricmp( token, "PARTY_INVITE" ) )
{
GetActionTableData(&g_actionTable[ACTION_PARTY_INVITE],ACTION_PARTY_INVITE,token);
}
else if( !stricmp( token, "PARTY_OUT" ) )
{
GetActionTableData(&g_actionTable[ACTION_PARTY_OUT],ACTION_PARTY_OUT,token);
}
else if( !stricmp( token, "PARTY_FORCEDOUT" ) )
{
GetActionTableData(&g_actionTable[ACTION_PARTY_FORCEDOUT],ACTION_PARTY_FORCEDOUT,token);
}
else if( !stricmp( token, "PARTY_DISORGANIZE" ) )
{
GetActionTableData(&g_actionTable[ACTION_PARTY_DISORGANIZE],ACTION_PARTY_DISORGANIZE,token);
}
else if( !stricmp( token, "MAP" ) )
{
GetActionTableData(&g_actionTable[ACTION_MAP],ACTION_MAP,token);
}
else if( !stricmp( token, "BOOTH" ) )
{
GetActionTableData(&g_actionTable[ACTION_BOOTH],ACTION_BOOTH,token);
}
else if( !stricmp( token, "FRIEND_MAKE" ) )
{
GetActionTableData(&g_actionTable[ACTION_FRIEND_MAKE],ACTION_FRIEND_MAKE,token);
}
else if( !stricmp( token, "FRIEND_BYE" ) )
{
GetActionTableData(&g_actionTable[ACTION_FRIEND_BYE],ACTION_FRIEND_BYE,token);
}
else if( !stricmp( token, "SHOUT" ) )
{
GetActionTableData(&g_actionTable[ACTION_SHOUT],ACTION_SHOUT,token);
}
else if( !stricmp( token, "BOW" ) )
{
GetActionTableData(&g_actionTable[ACTION_BOW],ACTION_BOW,token);
}
else if( !stricmp( token, "CHATTING" ) )
{
GetActionTableData(&g_actionTable[ACTION_CHATTING],ACTION_CHATTING,token);
}
else if( !stricmp(token, "REGISTHELPER") )
{
GetActionTableData(&g_actionTable[ACTION_REGIST_HELPER],ACTION_REGIST_HELPER,token);
}
else if(!stricmp(token, "GIVEPOINT"))
{
GetActionTableData(&g_actionTable[ACTION_GIVE_POINT],ACTION_GIVE_POINT,token);
}
}
if(Version != ACTION_TABLE_VERSION)
{
MessageBox(NULL,"Action Table Version ... Error! ",NULL,MB_OK);
}
}
int LoadGenCapabilityTable( char *filename )
{
char* token;
int idx, level, genCapability, limitGenLevel, type;
g_script.Load( filename );
g_script.BeginParse();
for( int i = 0; i < 100; i ++ )
memset( &g_skillGradeClassTable[i], 0, sizeof( skillGradeClass_t ) );
while( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == NULL ) break;
if( !stricmp( token, "SKILL_CLASS" ) )
{
token = g_script.GetNextToken( true );
idx = atoi( token );
type = 0;
}
else if( !stricmp( token, "MONSTER_GEN_CAPABILITY" ) )
{
type = 1;
}
else if( token[0] == '{' )
{
while ( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == '}' ) break;
level = atoi( token );
token = g_script.GetNextToken( true );
if( type == 0 )
{
genCapability = atoi( token );
token = g_script.GetNextToken( true );
limitGenLevel = atoi( token );
g_skillGradeClassTable[idx].genCapability[level] = genCapability;
g_skillGradeClassTable[idx].limitGenLevel[level] = limitGenLevel;
}
else
{
g_genCapabilityTable.genCapability[level] = atoi( token );
}
}
}
}
return( 1 );
}
int LoadItemCraftTableForServer( char* filename )
{
char* token;
int numSourceItem, numRequireSkill, numResultItem, numOptionIdx;
g_script.Load( filename );
g_script.BeginParse();
for( int i = 0; i < MAX_NUMBER_OF_ITEM_CRAFT_TABLE; i ++ )
memset( &g_itemCraftTable[i], 0, sizeof( itemCraftTable_t ) );
g_itemCraftTableNumber = 0;
itemCraftTable_t TempItemCraftTable;
while( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == NULL ) break;
memset(&TempItemCraftTable,0,sizeof(itemCraftTable_t));
TempItemCraftTable.m_nMembership_type=-1;
if( token[0] == '{' )
{
while ( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == '}' ) break;
if( token[0] == NULL ) break;
if( !stricmp( token, "craft_grade" ) )
{
token = g_script.GetNextToken( true );
TempItemCraftTable.craftGrade = atoi( token );
}
else if( !stricmp( token, "success_probability" ) )
{
token = g_script.GetNextToken( true );
TempItemCraftTable.successProbability = atof( token );
}
else if( !stricmp( token, "craft_cost" ) )
{
token = g_script.GetNextToken( true );
TempItemCraftTable.craftCost = atoi( token );
}
else if( !stricmp( token, "craft_special_type" ) )
{
token = g_script.GetNextToken( true );
TempItemCraftTable.specialType = atoi( token );
}
else if( !stricmp( token, "craft_event_index" ) )
{
token = g_script.GetNextToken( true );
TempItemCraftTable.m_lEventIndex = atoi( token );
}
else if( !stricmp( token, "event_type" ) )
{
token = g_script.GetNextToken( true );
TempItemCraftTable.m_btEventType = atoi( token );
}
else if( !stricmp( token, "craft_cheat_name" ) )
{
token = g_script.GetNextToken( true );
int len = strlen(token);
if(len > 20)
{
wsprintf(TempItemCraftTable.m_chCheatName,"NULL");
}
else
{
wsprintf(TempItemCraftTable.m_chCheatName,"%s",token);
}
}
else if( !stricmp( token, "korea" ) )
{
token = g_script.GetNextToken( true );
while( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == '}' ) break;
if( token[0] == '{' )
{
while( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == '}' ) break;
if( !stricmp( token, "membership_type" ) )
{
token = g_script.GetNextToken( true );
TempItemCraftTable.m_nMembership_type = atoi( token );
}
}
}
}
}
else if( !stricmp( token, "result_etc" ) )
{
token = g_script.GetNextToken( true );
while( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == '}' ) break;
if( token[0] == '{' )
{
while( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == '}' ) break;
if( !stricmp( token, "nak" ) )
{
token = g_script.GetNextToken( true );
TempItemCraftTable.m_lResultNak = atoi( token );
}
else if( !stricmp( token, "exp" ) )
{
token = g_script.GetNextToken( true );
TempItemCraftTable.m_lResultExp = atoi( token );
}
else if( !stricmp( token, "icon" ) )
{
token = g_script.GetNextToken( true );
TempItemCraftTable.m_nResultMark = atoi( token );
}
}
}
}
}
else if( !stricmp( token, "source_item" ) )
{
numSourceItem = 0;
token = g_script.GetNextToken( true );
while( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == '}' ) break;
if( token[0] == '{' )
{
numOptionIdx = 0;
while( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == '}' ) break;
if( !stricmp( token, "index" ) )
{
token = g_script.GetNextToken( true );
TempItemCraftTable.sourceItem[numSourceItem].itemIndex = atoi( token );
}
else if( !stricmp( token, "number" ) )
{
token = g_script.GetNextToken( true );
TempItemCraftTable.sourceItem[numSourceItem].itemCount = atoi( token );
}
else if( !stricmp( token, "option_index" ) )
{
token = g_script.GetNextToken( true );
TempItemCraftTable.sourceItem[numSourceItem].reqOptionIndex[numOptionIdx] = atoi( token );
numOptionIdx ++;
}
else if( !stricmp( token, "above_option_number" ) )
{
TempItemCraftTable.sourceItem[numSourceItem].reqOptionCountType = 0;
token = g_script.GetNextToken( true );
TempItemCraftTable.sourceItem[numSourceItem].reqOptionCount = atoi( token );
}
else if( !stricmp( token, "equal_option_number" ) )
{
TempItemCraftTable.sourceItem[numSourceItem].reqOptionCountType = 1;
token = g_script.GetNextToken( true );
TempItemCraftTable.sourceItem[numSourceItem].reqOptionCount = atoi( token );
}
else if( !stricmp( token, "below_option_number" ) )
{
TempItemCraftTable.sourceItem[numSourceItem].reqOptionCountType = 2;
token = g_script.GetNextToken( true );
TempItemCraftTable.sourceItem[numSourceItem].reqOptionCount = atoi( token );
}
}
TempItemCraftTable.sourceItem[numSourceItem].numReqOptionIndex = numOptionIdx;
numSourceItem ++;
}
}
TempItemCraftTable.numSourceItem = numSourceItem;
}
else if( !stricmp( token, "require_skill" ) )
{
numRequireSkill = 0;
token = g_script.GetNextToken( true );
while( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == '}' ) break;
if( token[0] == '{' )
{
while( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == '}' ) break;
if( !stricmp( token, "index" ) )
{
token = g_script.GetNextToken( true );
TempItemCraftTable.requireSkill[numRequireSkill].skillIndex = atoi( token );
}
else if( !stricmp( token, "above_level" ) )
{
TempItemCraftTable.requireSkill[numRequireSkill].reqSkillLevelType = 0;
token = g_script.GetNextToken( true );
TempItemCraftTable.requireSkill[numRequireSkill].reqSkillLevel = atoi( token );
}
else if( !stricmp( token, "equal_level" ) )
{
TempItemCraftTable.requireSkill[numRequireSkill].reqSkillLevelType = 1;
token = g_script.GetNextToken( true );
TempItemCraftTable.requireSkill[numRequireSkill].reqSkillLevel = atoi( token );
}
else if( !stricmp( token, "below_level" ) )
{
TempItemCraftTable.requireSkill[numRequireSkill].reqSkillLevelType = 2;
token = g_script.GetNextToken( true );
TempItemCraftTable.requireSkill[numRequireSkill].reqSkillLevel = atoi( token );
}
}
numRequireSkill ++;
}
}
TempItemCraftTable.numRequireSkill = numRequireSkill;
}
else if( !stricmp( token, "result_item" ) )
{
numResultItem = 0;
token = g_script.GetNextToken( true );
while( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == '}' ) break;
if( token[0] == '{' )
{
TempItemCraftTable.resultItem[numResultItem].optionGroupIdx = -1;
while( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == '}' ) break;
if( !stricmp( token, "index" ) )
{
token = g_script.GetNextToken( true );
TempItemCraftTable.resultItem[numResultItem].itemIndex = atoi( token );
}
else if( !stricmp( token, "number" ) )
{
token = g_script.GetNextToken( true );
TempItemCraftTable.resultItem[numResultItem].itemCount = atoi( token );
}
else if( !stricmp( token, "option_grade") )
{
token = g_script.GetNextToken( true );
TempItemCraftTable.resultItem[numResultItem].optionGrade = atoi( token );
}
else if( !stricmp( token, "rareitem_grade") )
{
token = g_script.GetNextToken( true );
TempItemCraftTable.resultItem[numResultItem].rareItemGrade = atoi( token );
}
else if( !stricmp( token, "optiongroup") )
{
token = g_script.GetNextToken( true );
TempItemCraftTable.resultItem[numResultItem].optionGroupIdx = atoi( token );
}
}
numResultItem ++;
}
}
TempItemCraftTable.numResultItem = numResultItem;
}
}
if(TempItemCraftTable.specialType == CRAFT_TYPE_EVENT)
{
TempItemCraftTable.idx = g_ifMng->m_EventCraftWin->GetTableSize();
g_ifMng->m_EventCraftWin->Push(TempItemCraftTable);
}
else
{
TempItemCraftTable.idx = g_itemCraftTableNumber;
memcpy(&g_itemCraftTable[g_itemCraftTableNumber],&TempItemCraftTable,sizeof(itemCraftTable_t));
g_itemCraftTableNumber ++;
}
}
}
return 1;
}
int LoadQuestScrollTable( char* filename )
{
char token[512];
int ret, idx = 0;
for( int i = 0; i < MAX_NUMBER_OF_QUESTSCROLL_TABLE; i ++ )
{
memset( &g_questscrollTable[i], 0, sizeof( questscrollTable_t ) );
g_questscrollTable[i].Index = -1;
}
g_questscrollTableNumber = 0;
if ( !g_script.Load( filename ) ) return 0;
g_script.BeginParse();
while( 1 )
{
ret = g_script.GetCSVToken( token );
if ( ret == 1 ) break;
if ( !( token[0] > 47 && token[0] < 58 ) )
{
if ( ret == 2 ) break;
while (1)
{
ret = g_script.GetCSVToken( token );
if ( ret == 1 ) return 1;
if ( ret == 2 ) break;
}
continue;
}
g_questscrollTable[idx].Index = atoi( token );
ret = g_script.GetCSVToken( token );
strcpy( g_questscrollTable[idx].name, token );
if ( ret == 1 )
{
g_questscrollTableNumber++;
break;
}
if ( ret == 2 )
{
idx++;
g_questscrollTableNumber++;
continue;
}
for (int j=0; j < ( sizeof( QSDATAFIELD ) / 4 ); j++)
{
ret = g_script.GetCSVToken( token );
g_questscrollTable[idx].dataField[j] = atoi( token );
if ( ret == 1 )
{
g_questscrollTableNumber++;
return 1;
}
if ( ret == 2 ) break;
}
ret = g_script.GetCSVToken( token );
strcpy( g_questscrollTable[idx].description, token );
idx++;
g_questscrollTableNumber++;
}
return 1;
}
int LoadAutoQuestScrollTable( char* filename )
{
char token[512];
int ret, idx = 0;
for( int i = 0; i < MAX_NUMBER_OF_AUTOQUESTSCROLL_TABLE; i ++ )
{
memset( &g_autoquestscrollTable[i], 0, sizeof( autoQuestScrollTable_t ) );
g_autoquestscrollTable[i].Index = -1;
}
g_autoquestscrollTableNumber = 0;
if ( !g_script.Load( filename ) ) return 0;
g_script.BeginParse();
while( 1 )
{
ret = g_script.GetCSVToken( token );
if ( ret == 1 ) break;
if ( !( token[0] > 47 && token[0] < 58 ) )
{
if ( ret == 2 ) break;
while (1)
{
ret = g_script.GetCSVToken( token );
if ( ret == 1 ) return 1;
if ( ret == 2 ) break;
}
continue;
}
g_autoquestscrollTable[idx].Index = atoi( token );
ret = g_script.GetCSVToken( token );
strcpy( g_autoquestscrollTable[idx].name, token );
if ( ret == 1 )
{
g_autoquestscrollTableNumber++;
break;
}
if ( ret == 2 )
{
idx++;
g_autoquestscrollTableNumber++;
continue;
}
for (int j=0; j < ( sizeof( AUTOQSDATAFIELD ) / 4 ); j++)
{
ret = g_script.GetCSVToken( token );
g_autoquestscrollTable[idx].dataField[j] = atoi( token );
if ( ret == 1 )
{
g_autoquestscrollTableNumber++;
return 1;
}
if ( ret == 2 ) break;
}
idx++;
g_autoquestscrollTableNumber++;
}
return 1;
}
int LoadOptionTable( char* filename )
{
char token[128];
int ret;
optionTable_t *pOpt;
if ( !g_script.Load( filename ) ) return 0;
g_script.BeginParse();
for( int i = 0; i < MAX_COUNT_OPTION_TABLE; i ++ )
{
memset( &g_optionTable[i], 0, sizeof( optionTable_t ) );
g_optionTable[i].idx = -1;
}
while( 1 )
{
ret = g_script.GetCSVToken( token );
if( ret == CSV_EndOfLine ) break;
}
while( 1 )
{
ret = g_script.GetCSVToken( token );
pOpt = &g_optionTable[ atoi( token ) ];
pOpt->idx = atoi( token );
ret = g_script.GetCSVToken( token );
strcpy( pOpt->name, token );
ret = g_script.GetCSVToken( token );
strcpy( pOpt->printing, token );
ret = g_script.GetCSVToken( token );
for( i = 0; i < MAX_OPTION_GRADE; i ++ )
{
ret = g_script.GetCSVToken( token );
}
if( ret == CSV_EndOfFile ) break;
if( ret == CSV_EndOfLine ) continue;
return( false );
}
return true;
}
int MakeOptionTable( char* optionTableFilename, char* valueTableFilename, optionTable_t optionTable[] )
{
char token[128];
int ret;
optionTable_t *pOpt;
if ( !g_script.Load( optionTableFilename ) ) return 0;
g_script.BeginParse();
for( int i = 0; i < MAX_COUNT_OPTION_TABLE; i ++ )
{
memset( &optionTable[i], 0, sizeof( optionTable_t ) );
optionTable[i].idx = -1;
}
while( 1 )
{
ret = g_script.GetCSVToken( token );
if( ret == CSV_EndOfLine ) break;
}
while( 1 )
{
ret = g_script.GetCSVToken( token );
pOpt = &optionTable[ atoi( token ) ];
pOpt->idx = atoi( token );
ret = g_script.GetCSVToken( token );
strcpy( pOpt->name, token );
ret = g_script.GetCSVToken( token );
strcpy( pOpt->printing, token );
ret = g_script.GetCSVToken( token );
pOpt->dropYN = atoi( token );
ret = g_script.GetCSVToken( token );
pOpt->fixationPro = atoi( token );
ret = g_script.GetCSVToken( token );
pOpt->optionType = atoi( token );
for( i = 0; i < MAX_OPTION_ITEM_TYPE; i ++ )
{
ret = g_script.GetCSVToken( token );
pOpt->itemType[i] = atoi( token );
}
pOpt->availableOn = 0;
if( pOpt->optionType == -1 )
{
for( int j = 0; j < MAX_OPTION_ITEM_TYPE; j ++ )
{
if( pOpt->itemType[j] < 0 ) break;
if( pOpt->itemType[j] == 0 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_WEAPONS;
if( pOpt->itemType[j] == 1 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_DAGGER;
if( pOpt->itemType[j] == 2 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_1HSWORD;
if( pOpt->itemType[j] == 3 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_2HSWORD;
if( pOpt->itemType[j] == 4 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_BOW;
if( pOpt->itemType[j] == 5 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_STAFF;
if( pOpt->itemType[j] == 6 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_SPIRITOR;
if( pOpt->itemType[j] == 7 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_CLAW;
if( pOpt->itemType[j] == 8 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_ARMORS;
if( pOpt->itemType[j] == 9 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_UPPER;
if( pOpt->itemType[j] == 10 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_LOWER;
if( pOpt->itemType[j] == 11 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_AIRPROTECTOR;
if( pOpt->itemType[j] == 12 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_BODYPROTECTOR;
if( pOpt->itemType[j] == 13 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_GLOVES;
if( pOpt->itemType[j] == 14 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_BOOTS;
if( pOpt->itemType[j] == 15 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_RING;
if( pOpt->itemType[j] == 16 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_NECKLACE;
if( pOpt->itemType[j] == 17 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_BRACELET;
if( pOpt->itemType[j] == 18 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_EARRING;
if( pOpt->itemType[j] == 19 ) pOpt->availableOn |= OPTION_AVAILABLE_ON_EPACK;
}
}
else if( pOpt->optionType == 0 )
{
pOpt->availableOn |= 0xffffffff;
}
else if( pOpt->optionType == 1 )
{
pOpt->availableOn |= OPTION_AVAILABLE_ON_WEAPONS;
}
else if( pOpt->optionType == 2 )
{
pOpt->availableOn |= OPTION_AVAILABLE_ON_ARMORS;
}
else if( pOpt->optionType == 3 )
{
pOpt->availableOn |= OPTION_AVAILABLE_ON_RING;
pOpt->availableOn |= OPTION_AVAILABLE_ON_NECKLACE;
pOpt->availableOn |= OPTION_AVAILABLE_ON_BRACELET;
pOpt->availableOn |= OPTION_AVAILABLE_ON_EARRING;
}
else if( pOpt->optionType == 4 )
{
pOpt->availableOn |= OPTION_AVAILABLE_ON_EPACK;
}
if( ret == CSV_EndOfFile ) break;
if( ret == CSV_EndOfLine ) continue;
return( false );
}
if ( !g_script.Load( valueTableFilename ) ) return false;
g_script.BeginParse();
char valueName[64];
int optionStoneGrade;
int itemType;
float value[MAX_OPTION_GRADE];
while( 1 )
{
ret = g_script.GetCSVToken( token );
if( ret == CSV_EndOfLine ) break;
}
while( 1 )
{
ret = g_script.GetCSVToken( token );
ret = g_script.GetCSVToken( token );
strcpy( valueName, token );
ret = g_script.GetCSVToken( token );
pOpt = &optionTable[ atoi( token ) ];
ret = g_script.GetCSVToken( token );
optionStoneGrade = atoi( token );
ret = g_script.GetCSVToken( token );
itemType = atoi( token );
for( i = 0; i < MAX_OPTION_GRADE; i ++ )
{
ret = g_script.GetCSVToken( token );
value[i] = atof( token );
}
if( optionStoneGrade == -1 )
{
for( i = 0; i < MAX_OPTIONSTONE_GRADE; i ++ )
{
strcpy( pOpt->optValue[i].value_item[itemType].valueName, valueName );
if( itemType == 0 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_WEAPONS;
if( itemType == 1 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_DAGGER;
if( itemType == 2 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_1HSWORD;
if( itemType == 3 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_2HSWORD;
if( itemType == 4 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_BOW;
if( itemType == 5 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_STAFF;
if( itemType == 6 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_SPIRITOR;
if( itemType == 7 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_CLAW;
if( itemType == 8 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_ARMORS;
if( itemType == 9 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_UPPER;
if( itemType == 10 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_LOWER;
if( itemType == 11 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_AIRPROTECTOR;
if( itemType == 12 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_BODYPROTECTOR;
if( itemType == 13 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_GLOVES;
if( itemType == 14 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_BOOTS;
if( itemType == 15 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_RING;
if( itemType == 16 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_NECKLACE;
if( itemType == 17 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_BRACELET;
if( itemType == 18 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_EARRING;
if( itemType == 19 ) pOpt->optValue[i].availableOn |= OPTION_AVAILABLE_ON_EPACK;
for( int j = 0; j < MAX_OPTION_GRADE; j ++ )
{
pOpt->optValue[i].value_item[itemType].value[j] = value[j];
}
}
}
else
{
strcpy( pOpt->optValue[optionStoneGrade].value_item[itemType].valueName, valueName );
if( itemType == 0 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_WEAPONS;
if( itemType == 1 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_DAGGER;
if( itemType == 2 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_1HSWORD;
if( itemType == 3 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_2HSWORD;
if( itemType == 4 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_BOW;
if( itemType == 5 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_STAFF;
if( itemType == 6 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_SPIRITOR;
if( itemType == 7 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_CLAW;
if( itemType == 8 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_ARMORS;
if( itemType == 9 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_UPPER;
if( itemType == 10 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_LOWER;
if( itemType == 11 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_AIRPROTECTOR;
if( itemType == 12 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_BODYPROTECTOR;
if( itemType == 13 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_GLOVES;
if( itemType == 14 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_BOOTS;
if( itemType == 15 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_RING;
if( itemType == 16 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_NECKLACE;
if( itemType == 17 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_BRACELET;
if( itemType == 18 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_EARRING;
if( itemType == 19 ) pOpt->optValue[optionStoneGrade].availableOn |= OPTION_AVAILABLE_ON_EPACK;
for( i = 0; i < MAX_OPTION_GRADE; i ++ )
{
pOpt->optValue[optionStoneGrade].value_item[itemType].value[i] = value[i];
}
}
if( ret == CSV_EndOfFile ) break;
if( ret == CSV_EndOfLine ) continue;
return( false );
}
return true;
}
int LoadSummonMonsterTable( char *filename, SummonMonster_t summonTable[], int &summontablenumber)
{
char token[128];
int ret;
int count = 0;
if ( !g_script.Load( filename ) ) return 0;
g_script.BeginParse();
for( int i = 0; i < MAX_NUMBER_OF_SUMMON_MONSTER_TABLE; i ++ )
{
memset( &summonTable[i], 0, sizeof( SummonMonster_t ) );
summonTable[i].idx = -1;
summonTable[i].SummonWorldIdx = -1;
}
while( 1 )
{
ret = g_script.GetCSVToken( token );
if( ret == CSV_EndOfLine ) break;
}
while( 1 )
{
SummonMonster_t* pTable = NULL;
if ( count > MAX_NUMBER_OF_SUMMON_MONSTER_TABLE)
return false;
pTable = &summonTable[count];
if ( pTable == NULL )
return false;
ret = g_script.GetCSVToken( token );
ret = g_script.GetCSVToken( token );
pTable->idx = atoi( token );
ret = g_script.GetCSVToken( token );
strcpy (pTable->doc, token);
ret = g_script.GetCSVToken( token );
strcpy (pTable->name, token);
ret = g_script.GetCSVToken( token );
pTable->SummonTime = atof(token);
ret = g_script.GetCSVToken( token );
pTable->SummonWorldIdx = atoi( token );
count++;
if( ret == CSV_EndOfFile ) break;
if( ret == CSV_EndOfLine ) continue;
return( false );
}
summontablenumber = count;
return true;
return 1;
}
int LoadGonryunBattlePracticeTableReword(char *filenameReword, BattleRewordField_t *pBattleRewordField)
{
char token[512];
if ( !g_script.Load( filenameReword ) ) return 0;
g_script.BeginParse();
int ret, idx = 0;
while (1) {
ret = g_script.GetCSVToken( token );
if ( ret == 1 ) break;
if ( !( token[0] > 47 && token[0] < 58 ) )
{
if ( ret == 2 ) break;
while (1)
{
ret = g_script.GetCSVToken( token );
if ( ret == 1 ) return 1;
if ( ret == 2 ) break;
}
continue;
}
pBattleRewordField->m_irewordId=atoi( token );
ret =g_script.GetCSVToken( token );
strncpy(pBattleRewordField->m_czname, token,strlen(token)+1);
ret = g_script.GetCSVToken( token );
pBattleRewordField->m_irewordType=atoi( token );
ret =g_script.GetCSVToken( token );
pBattleRewordField->m_iexp=atoi( token );
ret =g_script.GetCSVToken( token );
pBattleRewordField->m_iexpRate=atoi( token );
ret = g_script.GetCSVToken( token );
pBattleRewordField->m_irewordItemId=atoi( token );
ret =g_script.GetCSVToken( token );
pBattleRewordField->m_iitemRate=atoi( token );
ret = g_script.GetCSVToken( token );
if ( ret == 1 )
{
return 1;
}
if ( ret == 2 ) break;
}
return 1;
}
int LoadGonryunBattlePracticeTableRewordItem(char *filenameRewordItem, BattleRewordItem_t pBattleRewordItem[])
{
char token[512];
if ( !g_script.Load( filenameRewordItem ) ) return 0;
g_script.BeginParse();
int ret=0, idx = 0;
while (1) {
ret = g_script.GetCSVToken( token );
if ( ret == 1 ) break;
if ( !( token[0] > 47 && token[0] < 58 ) )
{
if ( ret == 2 ) break;
while (1)
{
ret =g_script.GetCSVToken( token );
if ( ret == 1 ) return 1;
if ( ret == 2 ) break;
}
continue;
}
pBattleRewordItem[idx].m_irewordItemId=atoi( token );
ret = g_script.GetCSVToken( token );
pBattleRewordItem[idx].m_iitemType= atoi( token );
ret = g_script.GetCSVToken( token );
pBattleRewordItem[idx].m_iitemId=atoi( token );
ret = g_script.GetCSVToken( token );
pBattleRewordItem[idx].m_iitemNumber=atoi( token );
ret =g_script.GetCSVToken( token );
pBattleRewordItem[idx].m_iitemRate=atoi( token );
ret = g_script.GetCSVToken( token );
if ( ret == 1 )
{
idx++;
return 1;
}
if ( ret == 2 )
{
idx++;
continue;
}
}
return 1;
}
int LoadGolryunManagerTable( char* filename )
{
char token[512];
int ret, idx = 0;
for( int i = 0; i < MAX_NUMBER_OF_GOLRYUN_MANAGER_TABLE; i ++ )
{
memset( &g_golryunManagerTable[i], 0, sizeof( golryunManagerTable_t ) );
g_golryunManagerTable[i].index = -1;
}
if ( !g_script.Load( filename ) ) return 0;
g_script.BeginParse();
while( 1 )
{
ret = g_script.GetCSVToken( token );
if ( ret == 1 ) break;
if ( !( token[0] > 47 && token[0] < 58 ) )
{
if ( ret == 2 ) break;
while (1)
{
ret = g_script.GetCSVToken( token );
if ( ret == 1 ) return 1;
if ( ret == 2 ) break;
}
continue;
}
g_golryunManagerTable[idx].index = atoi( token );
ret = g_script.GetCSVToken( token );
g_golryunManagerTable[idx].bcontrol = atoi( token );
ret = g_script.GetCSVToken( token );
g_golryunManagerTable[idx].bgamble = atoi( token );
ret = g_script.GetCSVToken( token );
g_golryunManagerTable[idx].levelMin = atoi( token );
ret = g_script.GetCSVToken( token );
g_golryunManagerTable[idx].levelMax = atoi( token );
ret = g_script.GetCSVToken( token );
g_golryunManagerTable[idx].joinNum = atoi( token );
ret = g_script.GetCSVToken( token );
g_golryunManagerTable[idx].bdeposit = atoi( token );
ret = g_script.GetCSVToken( token );
g_golryunManagerTable[idx].deposit = atoi( token );
ret = g_script.GetCSVToken( token );
g_golryunManagerTable[idx].progressIdx = atoi( token );
idx++;
}
return 1;
}
int LoadGolryunProgressTable( char* filename )
{
char token[512];
int ret, idx = 0;
for( int i = 0; i < MAX_NUMBER_OF_GOLRYUN_MANAGER_TABLE; i ++ )
{
for(int j=0; j<7; j++)
{
g_golryunProgressTable[i].statusTime[j] = 0;
}
g_golryunManagerTable[i].index = -1;
}
if ( !g_script.Load( filename ) ) return 0;
g_script.BeginParse();
while( 1 )
{
ret = g_script.GetCSVToken( token );
if ( ret == 1 ) break;
if ( !( token[0] > 47 && token[0] < 58 ) )
{
if ( ret == 2 ) break;
while (1)
{
ret = g_script.GetCSVToken( token );
if ( ret == 1 ) return 1;
if ( ret == 2 ) break;
}
continue;
}
g_golryunProgressTable[idx].index = atoi( token );
for(i=0; i<7; i++)
{
ret = g_script.GetCSVToken( token );
g_golryunProgressTable[idx].statusTime[i] = atoi( token );
}
ret = g_script.GetCSVToken( token );
g_golryunProgressTable[idx].rewardIdx = atoi( token );
idx++;
}
return 1;
}
char *g_lTableToken[] =
{
"_kr",
"_en",
"_jp",
"_ch",
"_tw",
};
int LoadAllGameTable()
{
char filename[128], filename2[128];
sprintf( filename, "open%s.slt", g_lTableToken[g_cgv.languageType] );
if( !LoadItemClassTable( filename ) )
{
MessageBox( NULL, "Failure Item Class Table Loading!", "Error", MB_OK );
return 0;
}
sprintf( filename, "open%s.sit", g_lTableToken[g_cgv.languageType] );
if( !LoadItemTable( filename ) )
{
MessageBox( NULL, "Failure Item Table Loading!", "Error", MB_OK );
return 0;
}
sprintf( filename, "open%s.smt", g_lTableToken[g_cgv.languageType] );
if( !LoadMonsterTable( filename ) )
{
MessageBox( NULL, "Failure Monster Table Loading!", "Error", MB_OK );
return 0;
}
sprintf( filename, "open%s.skt", g_lTableToken[g_cgv.languageType] );
if( !g_SkillFile.LoadSkillTable( filename ) )
{
MessageBox( NULL, "Failure Skill Table Loading!", "Error", MB_OK );
return 0;
}
sprintf( filename, "QSTable%s.csv", g_lTableToken[g_cgv.languageType] );
if ( !LoadQuestScrollTable( filename ) )
{
MessageBox( NULL, "Failure Quest Scroll Table Loading!", "Error", MB_OK );
return 0;
}
sprintf( filename, "AqsTable%s.csv", g_lTableToken[g_cgv.languageType] );
if ( !LoadAutoQuestScrollTable( filename ) )
{
MessageBox( NULL, "Failure AutoQuest Scroll Table Loading!", "Error", MB_OK );
return 0;
}
sprintf( filename, "summontable%s.csv", g_lTableToken[g_cgv.languageType]);
if ( !LoadSummonMonsterTable( filename, g_summonMonstertable, g_summonMonstertableNumber))
{
MessageBox( NULL, "Failure Summon MonsterTable Loading!", "Error", MB_OK );
return 0;
}
sprintf( filename, "GonryunBattlePractice_RewardField%s.csv", g_lTableToken[g_cgv.languageType]);
if ( !LoadGonryunBattlePracticeTableReword( filename, &g_BattleRewordField) )
{
MessageBox( NULL, "LoadGonryunBattlePracticeTableReword!", "Error", MB_OK );
return 0;
}
sprintf( filename, "GonryunBattlePractice_RewardItem%s.csv", g_lTableToken[g_cgv.languageType]);
if ( !LoadGonryunBattlePracticeTableRewordItem( filename, g_BattleRewordItem))
{
MessageBox( NULL, "LoadGonryunBattlePracticeTableRewordItem!", "Error", MB_OK );
return 0;
}
sprintf( filename, "GolryunBattle_Manager.csv" );
if ( !LoadGolryunManagerTable( filename ) )
{
MessageBox( NULL, "Failure Golryun Manager Table Loading!", "Error", MB_OK );
return 0;
}
sprintf( filename, "GolryunBattle_Progress.csv" );
if ( !LoadGolryunProgressTable( filename ) )
{
MessageBox( NULL, "Failure Golryun Progress Table Loading!", "Error", MB_OK );
return 0;
}
LoadExpTableForClient( "newexptable.tbl" );
LoadGenExpTableForClient( "newGenExpTable.tbl" );
sprintf( filename, "OptTable%s.csv", g_lTableToken[g_cgv.languageType] );
sprintf( filename2, "ValueTable%s.csv", g_lTableToken[g_cgv.languageType] );
if ( !MakeOptionTable( filename, filename2, g_optionTable ) )
{
MessageBox( NULL, "Failure OptionTable or ValueTable Loading!", "Error", MB_OK );
return 0;
}
LoadActionTable( "action.tbl" );
LoadGenCapabilityTable( "GenCapability.tbl" );
LoadItemCraftTableForServer( "itemCraft.tbl" );
return 1;
}
#include <direct.h>
int g_screenCount = -1;
int GetScreenShotName()
{
HANDLE hSrch;
WIN32_FIND_DATA wfd;
BOOL bResult=TRUE;
char Path[255];
int filen = 0;
strcpy( Path, "../screenshot/*.jpg" );
if( g_screenCount == -1 )
{
hSrch = FindFirstFile(Path, &wfd);
if( hSrch == INVALID_HANDLE_VALUE )
{
g_screenCount = 0;
return( g_screenCount );
}
filen ++;
while (1)
{
bResult = FindNextFile(hSrch, &wfd);
if( !bResult ) break;
filen ++;
}
FindClose(hSrch);
g_screenCount = filen;
return( g_screenCount );
}
else g_screenCount ++;
return( g_screenCount );
}
void MakeScreenShot(IDirect3DDevice8* device, int screenx, int screeny)
{
char screenFolder[255];
char filename[255];
char temp[255];
memset( screenFolder, 0, 255 );
memset( filename, 0, 255 );
memset( temp, 0, 255 );
strcpy( screenFolder, "../screenshot/" );
mkdir( screenFolder );
int n = GetScreenShotName();
if( n / 10 == 0 )
{
itoa( n, temp, 10 );
sprintf( filename, "../screenshot/screen00%s.jpg", temp );
}
else if( n / 10 > 0 && n / 10 < 10 )
{
itoa( n, temp, 10 );
sprintf( filename, "../screenshot/screen0%s.jpg", temp );
}
else
{
itoa( n, temp, 10 );
sprintf( filename, "../screenshot/screen%s.jpg", temp );
}
TakeScreenShot( device, filename, screenx, screeny );
if( g_cgv.state == CLIENT_GAME_PROCESS )
{
sprintf( temp, g_LPACK.GetMassage( 0, 420 ), filename );
g_ifMng->AddSysMessage( temp );
}
}
void TakeScreenShot(IDirect3DDevice8* device, char* file_name, int screenx, int screeny)
{
LPDIRECT3DSURFACE8 frontbuf = NULL;
device->CreateImageSurface(screenx, screeny, D3DFMT_A8R8G8B8, &frontbuf);
HRESULT hr = device->GetFrontBuffer(frontbuf);
D3DLOCKED_RECT d3dlr;
frontbuf->LockRect( &d3dlr, NULL, 0 );
BYTE *imageData = (BYTE*)d3dlr.pBits;
BOOL bres = TRUE;
JPEG_CORE_PROPERTIES image;
ZeroMemory( &image, sizeof( JPEG_CORE_PROPERTIES ) );
BYTE* realImage;
int i, j;
long realsize = 0;
float temppoint;
realImage = new BYTE[screenx * screeny * 3];
for( i = 0; i < screeny; i ++ )
for( j = 0; j < screenx; j ++ )
{
temppoint = (float)imageData[ ( i * screenx + j ) * 4 + 0] * 1.3f;
if( temppoint > 255.0f ) temppoint = 255.0f;
realImage[realsize] = (int)temppoint;
realsize ++;
temppoint = (float)imageData[ ( i * screenx + j ) * 4 + 1] * 1.3f;
if( temppoint > 255.0f ) temppoint = 255.0f;
realImage[realsize] = (int)temppoint;
realsize ++;
temppoint = (float)imageData[ ( i * screenx + j ) * 4 + 2] * 1.3f;
if( temppoint > 255.0f ) temppoint = 255.0f;
realImage[realsize] = (int)temppoint;
realsize ++;
}
if( ijlInit( &image ) != IJL_OK )
{
ijlFree( &image );
frontbuf->UnlockRect();
frontbuf->Release();
GTH_SAFE_DELETE ( realImage );
return;
}
image.DIBWidth = screenx;
image.DIBHeight = screeny;
image.DIBBytes = realImage;
image.DIBColor = IJL_BGR;
image.JPGFile = const_cast<char*>(file_name);
image.JPGWidth = screenx;
image.JPGHeight = screeny;
if( ijlWrite( &image, IJL_JFILE_WRITEWHOLEIMAGE ) != IJL_OK )
{
ijlFree( &image );
frontbuf->UnlockRect();
frontbuf->Release();
GTH_SAFE_DELETE ( realImage );
return;
}
if( ijlFree( &image ) != IJL_OK )
{
ijlFree( &image );
frontbuf->UnlockRect();
frontbuf->Release();
GTH_SAFE_DELETE ( realImage );
return;
}
ijlFree( &image );
frontbuf->UnlockRect();
frontbuf->Release();
GTH_SAFE_DELETE ( realImage );
} | C++ |
#ifndef _SKELETON_H_F28HF98H30H4302H40_
#define _SKELETON_H_F28HF98H30H4302H40_
typedef struct
{
vec3_t position;
vec4_t rotation;
vec3_t scale;
vec4_t scale_axis;
} TAG;
typedef struct
{
char strBoneName [SIZE_BONENAME];
float fLength;
int iParentID;
int iNumChildBone;
int childBoneID [MAX_CHILDBONE];
} BONE;
class FX_CSkel
{
public:
FX_CSkel ();
~FX_CSkel ();
public:
int m_iNumBone;
int m_iNumRootBone;
int m_iRootBoneID [MAX_ROOTBONE_ID];
BONE* m_pBones;
int m_fileVersion;
INT m_iTagCount;
TAG m_Tag [MAX_TAG];
char m_strDesc [256];
FX_BONESTRUCT_ID m_pBoneStID;
public:
bool LoadData ( TCHAR *strFilename, CFileMng *fileMng );
VOID Clear ();
VOID Cleanup ();
void SetGroundTag ( const vec3_t in_pos );
};
#endif | C++ |
#include "../../global_def.h"
#include "../Common.h"
FX_CSkel::FX_CSkel ()
{
m_pBones = NULL;
Clear();
}
FX_CSkel::~FX_CSkel ()
{
}
VOID FX_CSkel::Clear ()
{
m_iNumBone = 0;
m_iNumRootBone = 0;
memset ( m_iRootBoneID, 0, sizeof (m_iRootBoneID) );
memset ( m_Tag, 0, sizeof (m_Tag) );
GTH_SAFE_DELETE ( m_pBones );
return;
}
bool FX_CSkel::LoadData ( char *strFilename,
CFileMng *fileMng )
{
BYTE *pFileBuffer;
int offset = 0;
pFileBuffer = fileMng ->ReadFileFromPack ( strFilename );
int allocatedMemory = 0;
#define __CALC_ALLOCATED_MEMORY(a) if( g_resCounter->Enabled() ) { allocatedMemory += (a); }
char version [MAX_PATH];
GetDataFromBuffer ( (void *)version, pFileBuffer, strlen("VERSION"), offset );
version [strlen("VERSION")] = NULL;
if ( strcmp ( version, "VERSION" ) )
{
m_fileVersion = 100;
offset = 4;
}
else
{
GetDataFromBuffer ( (void *)version, pFileBuffer, 3, offset );
version [3] = NULL;
m_fileVersion = atoi ( version );
if ( m_fileVersion < 100 )
{
m_fileVersion = 100;
}
GetDataFromBuffer ( (void *)version, pFileBuffer, 4, offset );
version [4] = NULL;
if ( strcmp ( version, "SKEL" ) )
{
}
}
int iDescLength;
GetDataFromBuffer ( (void *)&iDescLength, pFileBuffer, sizeof(int), offset );
GetDataFromBuffer ( (void *)m_strDesc, pFileBuffer, iDescLength, offset );
m_strDesc [iDescLength] = '\0';
GetDataFromBuffer ( (void *)&m_pBoneStID, pFileBuffer, sizeof(FX_BONESTRUCT_ID), offset );
GetDataFromBuffer ( (void *)&m_iNumBone, pFileBuffer, sizeof(int), offset );
#ifdef _FXDEBUG
CHECKERROR ( m_iNumBone <= 0, "Failed to read bone count!" )
#endif
m_pBones = new BONE [m_iNumBone];
__CALC_ALLOCATED_MEMORY( sizeof(BONE) * m_iNumBone - sizeof(BONE*) )
for ( int iBoneID = 0; \
iBoneID < m_iNumBone; \
++iBoneID )
{
BONE* thisBone = &m_pBones [iBoneID];
int iNameLength;
GetDataFromBuffer ( (void *)&iNameLength, pFileBuffer, sizeof(int), offset );
#ifdef _FXDEBUG
CHECKERROR ( iNameLength < 1, "Failed to read name length!" )
#endif
char* strBuffer;
strBuffer = new char [iNameLength];
GetDataFromBuffer ( (void *)strBuffer, pFileBuffer, iNameLength, offset );
memcpy ( thisBone->strBoneName, strBuffer, iNameLength );
GTH_SAFE_DELETE_ARRAY ( strBuffer );
GetDataFromBuffer ( (void *)&thisBone ->fLength, pFileBuffer, sizeof(float), offset );
GetDataFromBuffer ( (void *)&thisBone ->iParentID, pFileBuffer, sizeof(int), offset );
if ( -1 == thisBone ->iParentID )
m_iRootBoneID [m_iNumRootBone++] = thisBone ->iParentID;
GetDataFromBuffer ( (void *)&thisBone->iNumChildBone, pFileBuffer, sizeof(int), offset );
#ifdef _FXDEBUG
CHECKERROR ( thisBone ->iNumChildBone < 0, "Failed to read child count!" )
#endif
GetDataFromBuffer ( (void *)&thisBone->childBoneID [0], pFileBuffer, sizeof(int) * thisBone ->iNumChildBone, offset );
}
GetDataFromBuffer ( (void *)&m_iTagCount, pFileBuffer, sizeof(int), offset );
GetDataFromBuffer ( (void *)m_Tag, pFileBuffer, sizeof(TAG) * m_iTagCount, offset );
for ( int index = 0; \
index < m_iTagCount; \
++index )
{
if ( m_Tag [index].rotation [3] == 0.0f )
m_Tag [index].rotation [3] = 1.0f;
}
GTH_SAFE_FREE ( pFileBuffer );
__CALC_ALLOCATED_MEMORY( sizeof(FX_CSkel) - sizeof(FX_CSkel*) )
if ( g_resCounter->Enabled() )
{
g_resCounter->Add_DataType( RESCOUNTER_SKEL, allocatedMemory );
}
return true;
}
VOID FX_CSkel::Cleanup ()
{
GTH_SAFE_DELETE_ARRAY ( m_pBones );
return;
}
void FX_CSkel::SetGroundTag ( const vec3_t in_pos )
{
VectorCopy ( m_Tag [ITEM_PART_GROUND].position, in_pos );
return;
} | C++ |
#include "../../global_def.h"
#include "../Common.h"
#include <ASSERT.H>
#define g_quatConjugate GLOBAL_QUAT_1
#define g_quatAfterTransform GLOBAL_QUAT_2
#define g_quatBuffer GLOBAL_QUAT_3
#define g_rot_matrix GLOBAL_DXMATRIX_1
#define g_unit_x GLOBAL_DXVEC3_3
#define g_inter GLOBAL_DXVEC3_2
#define g_after_start GLOBAL_DXVEC4_1
#define g_after_end GLOBAL_DXVEC4_2
#define g_interpolated GLOBAL_DXVEC4_3
#define g_groundvector GLOBAL_VEC3_1
FX_CAnim::FX_CAnim ()
{
m_eopframeIdx = NULL;
m_eoaframeIdx = NULL;
m_iNumTrack = 0;
m_dwNumIndices = 0;
m_dwNumVertices = 0;
}
FX_CAnim::~FX_CAnim()
{
}
bool FX_CAnim::Clear()
{
m_iNumTrack = 0;
m_dwNumIndices = 0;
m_dwNumVertices = 0;
m_eopframeIdx = NULL;
m_eoaframeIdx = NULL;
return true;
}
bool FX_CAnim::LoadData ( char *pszFilename,
CFileMng *fileMng )
{
BYTE *pFileBuffer;
int offset = 0;
int fileSize;
pFileBuffer = fileMng->ReadFileFromPack( pszFilename );
fileSize = (int)fileMng->GetFileSizeFromPack( pszFilename );
int allocatedMemory = 0;
#define __GETDATA(a, b) GetDataFromBuffer( (void *)(a), pFileBuffer, (b), offset )
#define __CALC_ALLOCATED_MEMORY(a) if( g_resCounter->Enabled() ) { allocatedMemory += (a); }
char version [MAX_PATH];
__GETDATA( version, strlen("VERSION") );
version [strlen("VERSION")] = NULL;
if ( strcmp ( version, "VERSION" ) )
{
m_fileVersion = 100;
offset = 4;
}
else
{
__GETDATA( version, 3 );
version [3] = NULL;
m_fileVersion = atoi ( version );
if ( m_fileVersion < 100 )
{
m_fileVersion = 100;
}
__GETDATA( version, 4 );
version [4] = NULL;
if ( strcmp ( version, "ANIM" ) )
{
}
}
int iDescLength;
__GETDATA( &iDescLength, sizeof(int) );
__GETDATA( m_strDesc, iDescLength );
m_strDesc[ iDescLength ] = '\0';
__GETDATA( &m_pBoneStID, sizeof(FX_BONESTRUCT_ID) );
__GETDATA( &m_animProperty, sizeof(ANIM_PROPERTY_t) );
__GETDATA( &m_totalFrames, sizeof(int) );
assert( m_totalFrames > 0 );
__GETDATA( &m_timePerFrame, sizeof(float) );
assert( m_timePerFrame >= 0.0f );
m_framePerTime = 1.0f / m_timePerFrame;
m_totalTime = m_timePerFrame * m_totalFrames;
m_rcptotalTime = 1.0f / m_totalTime;
__GETDATA( &m_iNumTrack, sizeof(int) );
assert( m_iNumTrack > 0 && m_iNumTrack <= MAX_COUNT_BONE_IN_CHAR );
m_Tracks = new TRACK[ m_iNumTrack ];
m_eopframeIdx = new int[ m_iNumTrack ];
m_eoaframeIdx = new int[ m_iNumTrack ];
__CALC_ALLOCATED_MEMORY( sizeof(TRACK) * m_iNumTrack - sizeof(TRACK*) )
__CALC_ALLOCATED_MEMORY( sizeof(int) * m_iNumTrack - sizeof(int*) )
__CALC_ALLOCATED_MEMORY( sizeof(int) * m_iNumTrack - sizeof(int*) )
for ( int iTrackID = 0; \
iTrackID < m_iNumTrack; \
++iTrackID )
{
TRACK *thisTrack = &m_Tracks[ iTrackID ];
__GETDATA( &thisTrack->iBoneID, sizeof(int) );
assert( thisTrack->iBoneID >= 0 );
__GETDATA( &thisTrack->iNumKeyframe, sizeof(int) );
assert( thisTrack->iNumKeyframe > 0 );
thisTrack->pKeyframe = new KEYFRAME[ thisTrack->iNumKeyframe ];
__CALC_ALLOCATED_MEMORY( sizeof(KEYFRAME) * thisTrack->iNumKeyframe - sizeof(KEYFRAME*) )
__GETDATA( thisTrack->pKeyframe, sizeof(KEYFRAME) * thisTrack->iNumKeyframe );
}
int numFrame;
__GETDATA( &numFrame, sizeof(int) );
m_boundBox = new bboxf_t[ numFrame ];
__GETDATA( m_boundBox, sizeof(bboxf_t) * numFrame );
__CALC_ALLOCATED_MEMORY( sizeof(bboxf_t) * numFrame - sizeof(bboxf_t*) )
if ( fileSize <= offset )
{
m_eopframe = ANIM_FRAME_ERROR_VALUE;
m_eoaframe = ANIM_FRAME_ERROR_VALUE;
}
else
{
__GETDATA( &m_eopframe, sizeof(float) );
__GETDATA( &m_eoaframe, sizeof(float) );
}
if ( m_eopframe > 100000.0f )
m_eopframe = ANIM_FRAME_ERROR_VALUE;
if ( m_eoaframe > 100000.0f )
m_eoaframe = ANIM_FRAME_ERROR_VALUE;
SetEOPFrame();
SetEOAFrame();
m_initialHeight = m_Tracks[ 0 ].pKeyframe[ 0 ].vecOffset[ 1 ];
GTH_SAFE_FREE( pFileBuffer );
__CALC_ALLOCATED_MEMORY( sizeof(FX_CAnim) - sizeof(FX_CAnim*) )
if ( g_resCounter->Enabled() )
{
char *lowercase = _strlwr( _strdup( pszFilename ) );
if ( strstr( lowercase, "mon" ) )
{
g_resCounter->Add_DataType( RESCOUNTER_ANIM_CHAR_MONSTER, allocatedMemory );
}
else if ( strstr( lowercase, "ava" ) )
{
g_resCounter->Add_DataType( RESCOUNTER_ANIM_CHAR_PC, allocatedMemory );
}
else if ( strstr( lowercase, "npc" ) )
{
g_resCounter->Add_DataType( RESCOUNTER_ANIM_CHAR_NPC, allocatedMemory );
}
free( lowercase );
}
return true;
}
void FX_CAnim::Cleanup ()
{
GTH_SAFE_DELETE_ARRAY ( m_boundBox );
for ( int i = 0; \
i < m_iNumTrack; \
++i )
{
GTH_SAFE_DELETE_ARRAY ( m_Tracks [i].pKeyframe );
}
GTH_SAFE_DELETE ( m_eoaframeIdx );
GTH_SAFE_DELETE ( m_eopframeIdx );
GTH_SAFE_DELETE_ARRAY ( m_Tracks );
return;
}
HRESULT FX_CAnim::Interpolate ( const KEYFRAME *prevKeyframe,
const KEYFRAME *nextKeyframe,
const float in_displacement,
KEYFRAME *result )
{
ZeroMemory( result, sizeof(KEYFRAME) );
result->frame = prevKeyframe->frame + (nextKeyframe->frame - prevKeyframe->frame) * in_displacement;
result->vecOffset[ 0 ] = prevKeyframe ->vecOffset[ 0 ] + in_displacement * ( nextKeyframe->vecOffset[ 0 ] - prevKeyframe->vecOffset[ 0 ] );
result->vecOffset[ 1 ] = prevKeyframe ->vecOffset[ 1 ] + in_displacement * ( nextKeyframe->vecOffset[ 1 ] - prevKeyframe->vecOffset[ 1 ] );
result->vecOffset[ 2 ] = prevKeyframe ->vecOffset[ 2 ] + in_displacement * ( nextKeyframe->vecOffset[ 2 ] - prevKeyframe->vecOffset[ 2 ] );
D3DXQuaternionSlerp( (D3DXQUATERNION *)result->quatRotate,
(D3DXQUATERNION *)prevKeyframe->quatRotate,
(D3DXQUATERNION *)nextKeyframe->quatRotate,
in_displacement );
D3DXQuaternionSlerp( (D3DXQUATERNION *)result->quatCoordinate,
(D3DXQUATERNION *)prevKeyframe->quatCoordinate,
(D3DXQUATERNION *)nextKeyframe->quatCoordinate,
in_displacement );
return S_OK;
}
void FX_CAnim::MakeInterpolatedVertices ( Fx_CHARACTER_t *in_char,
const int in_ended )
{
int index;
KEYFRAME *curKeyframe;
KEYFRAME *nextKeyframe;
if ( ANIMCHECK_RESULT_NORMAL == in_ended )
{
for ( index = 0; \
index < m_iNumTrack; \
++index )
{
curKeyframe = &m_Tracks[ index ].pKeyframe[ in_char->key_curIndex[ index ] ];
nextKeyframe = &m_Tracks[ index ].pKeyframe[ in_char->key_nextIndex[ index ] ];
Interpolate( curKeyframe, nextKeyframe, in_char->key_displace[ index ], &in_char->key_curFrames[ index ] );
}
}
else
{
for ( index = 0; \
index < m_iNumTrack; \
++index )
{
assert( in_char->key_curIndex[ index ] < m_Tracks[ index ].iNumKeyframe );
curKeyframe = &m_Tracks[ index ].pKeyframe[ in_char->key_curIndex[ index ] ];
}
}
TransformKeyframes( in_char );
return;
}
int FX_CAnim::CheckKeyframeState ( Fx_CHARACTER_t *in_char,
const int in_option )
{
if( m_iNumTrack > MAX_COUNT_BONE_IN_CHAR || m_iNumTrack <= 0 )
{
ErrorLog( "num track is over %s, %d anim(%d numTrack)", in_char->name, in_char->ani_curIdx, m_iNumTrack );
}
int index;
TRACK *thisTrack;
int endOfAnim = ANIMCHECK_RESULT_NORMAL;
int curFrame;
int nextFrame;
int finalFrame;
float oldTimeFrame = in_char ->ani_oldFrame;
float curTimeFrame;
if ( true == in_char->ani_curState.type.movable )
{
float fFrameSpeed = (in_char ->ani_curSpeed * m_timePerFrame) * in_char ->ren_generalSpeed * 0.01f;
if(fFrameSpeed > 0.0f)
{
curTimeFrame = oldTimeFrame + g_timer .GetElapsedTime () / fFrameSpeed;
}
else
{
curTimeFrame = oldTimeFrame;
}
}
else
{
float fFrameSpeed = (in_char ->ani_curSpeed * m_timePerFrame) * in_char ->ren_generalSpeed * 0.01f;
if(fFrameSpeed > 0.0f)
{
curTimeFrame = oldTimeFrame + g_timer .GetElapsedTime () / fFrameSpeed;
}
else
{
curTimeFrame =oldTimeFrame;
}
}
in_char ->ani_oldFrame = curTimeFrame;
in_char ->ani_fraction = curTimeFrame / m_totalFrames;
if ( ( in_option == ANIMCHECK_EOP ) &&
( curTimeFrame > m_eopframe ) )
{
memcpy( in_char->key_curIndex, m_eopframeIdx, sizeof(int) * m_iNumTrack );
memcpy( in_char->key_nextIndex, m_eopframeIdx, sizeof(int) * m_iNumTrack );
memset( in_char->key_displace, 0, sizeof (float) * m_iNumTrack );
endOfAnim = ANIMCHECK_RESULT_EOP;
}
else if ( ( in_option == ANIMCHECK_EOA ) &&
( curTimeFrame > m_eoaframe ) )
{
memcpy( in_char->key_curIndex, m_eoaframeIdx, sizeof(int) * m_iNumTrack );
memcpy( in_char->key_nextIndex, m_eoaframeIdx, sizeof(int) * m_iNumTrack );
memset( in_char->key_displace, 0, sizeof(float) * m_iNumTrack );
endOfAnim = ANIMCHECK_RESULT_EOA;
}
else
{
if( m_Tracks == NULL )
{
ErrorLog( "num track is over %s, %d anim(%d numTrack)", in_char->name, in_char->ani_curIdx, m_iNumTrack );
}
thisTrack = &m_Tracks [0];
for ( index = 0; \
index < m_iNumTrack; \
++index, ++thisTrack )
{
curFrame = in_char ->key_curIndex [index];
finalFrame = thisTrack ->iNumKeyframe - 1;
if ( finalFrame > curFrame )
{
while ( ( curTimeFrame > thisTrack ->pKeyframe [curFrame + 1] .frame ) &&
( curFrame != finalFrame ) )
{
++curFrame;
if (curFrame>=finalFrame)
{
curFrame=finalFrame;
break;
}
}
}
if ( curFrame != finalFrame )
{
nextFrame = curFrame + 1;
in_char ->key_displace [index] = ( curTimeFrame - thisTrack ->pKeyframe [curFrame].frame ) /
( thisTrack ->pKeyframe [nextFrame].frame - thisTrack ->pKeyframe [curFrame].frame );
}
else
if (curFrame==finalFrame)
{
nextFrame = curFrame;
endOfAnim = ANIMCHECK_RESULT_END;
}
else
{
nextFrame = curFrame + 1;
endOfAnim = ANIMCHECK_RESULT_END;
}
in_char ->key_curIndex [index] = curFrame;
in_char ->key_nextIndex [index] = nextFrame;
}
}
return endOfAnim;
}
void FX_CAnim::TransformKeyframes ( Fx_CHARACTER_t *in_char )
{
KEYFRAME *in_curKeyframe, *in_resultKeyframe;
in_curKeyframe = in_char ->key_curFrames;
in_resultKeyframe = in_char ->key_resultFrames;
static D3DXVECTOR3 vecGround;
static D3DXQUATERNION quatConjugate;
static D3DXQUATERNION quatAfterTransform;
static D3DXQUATERNION quatBuffer;
static const D3DXQUATERNION QUAT_UNIT_X( 1.0f, 0.0f, 0.0f, 0.0f );
for ( int index = 0; \
index < m_iNumTrack; \
++index )
{
m_iBoneID = m_Tracks[ index ].iBoneID;
if ( -1 == m_pSkeleton->m_pBones[ m_iBoneID ].iParentID )
{
in_char->stat_disp_x = in_curKeyframe[ index ].vecOffset[ 0 ] * in_char->stat_scale;
in_char->stat_disp_y = in_curKeyframe[ index ].vecOffset[ 1 ] * in_char->stat_scale;
in_char->stat_height = in_curKeyframe[ index ].vecOffset[ 2 ] * in_char->stat_scale;
DXVectorSet3( vecGround, 0.0f, 0.0f, -in_char->stat_height + 5.0f );
m_pSkeleton->SetGroundTag( (float *)&vecGround );
VectorSet( in_resultKeyframe[ index ].vecOffset, in_char->stat_disp_x, in_char->stat_disp_y, 0.0f );
Vector4Copy( in_resultKeyframe[ index ].quatCoordinate, in_curKeyframe[ index ].quatCoordinate );
Vector4Copy( in_resultKeyframe[ index ].quatRotate, in_curKeyframe[ index ].quatRotate );
}
else if ( 0 == m_pSkeleton->m_pBones[ m_iBoneID ].iParentID )
{
VectorCopy( in_resultKeyframe[ index ].vecOffset, in_resultKeyframe[ m_pSkeleton->m_pBones[ m_iBoneID ].iParentID ].vecOffset );
D3DXQuaternionMultiply( (D3DXQUATERNION *)in_resultKeyframe[ index ].quatCoordinate,
(D3DXQUATERNION *)in_resultKeyframe[ m_pSkeleton->m_pBones[ m_iBoneID ].iParentID ].quatCoordinate,
(D3DXQUATERNION *)in_curKeyframe[ index ].quatCoordinate );
}
else
{
D3DXQuaternionConjugate( &quatConjugate, (D3DXQUATERNION *)in_curKeyframe[ index ].quatRotate );
Fx_Quat3Multiply( (float *)&quatAfterTransform, (float *)&quatBuffer, in_curKeyframe[ index ].quatRotate, QUAT_UNIT_X, (float *)&quatConjugate );
in_resultKeyframe[ index ].vecOffset[ 0 ] = quatAfterTransform.x * m_pSkeleton->m_pBones[ m_iBoneID ].fLength +
in_resultKeyframe[ m_pSkeleton->m_pBones[ m_iBoneID ].iParentID ].vecOffset[ 0 ];
in_resultKeyframe[ index ].vecOffset[ 1 ] = quatAfterTransform.y * m_pSkeleton->m_pBones[ m_iBoneID ].fLength +
in_resultKeyframe[ m_pSkeleton->m_pBones[ m_iBoneID ].iParentID ].vecOffset[ 1 ];
in_resultKeyframe[ index ].vecOffset[ 2 ] = quatAfterTransform.z * m_pSkeleton->m_pBones[ m_iBoneID ].fLength +
in_resultKeyframe[ m_pSkeleton->m_pBones[ m_iBoneID ].iParentID ].vecOffset[ 2 ];
Vector4Copy( quatBuffer, in_curKeyframe[ index ].quatCoordinate );
Fx_Quat2Multiply( in_resultKeyframe[ index ].quatCoordinate, in_resultKeyframe[ m_pSkeleton->m_pBones[ m_iBoneID ].iParentID ].quatCoordinate, quatBuffer );
}
}
return;
}
void FX_CAnim::QuatInterpolate ( vec4_t out_quat,
const vec4_t in_start,
const vec4_t in_end,
const float in_disp )
{
const float error = 0.0001f;
g_unit_x [0] = 1.0f;
g_unit_x [1] = 0.0f;
g_unit_x [2] = 0.0f;
D3DXMatrixRotationQuaternion ( (D3DXMATRIX *)&g_rot_matrix, (D3DXQUATERNION *)in_start );
D3DXVec3Transform ( (D3DXVECTOR4 *)g_after_start, (D3DXVECTOR3 *)g_unit_x, (D3DXMATRIX *)&g_rot_matrix );
D3DXMatrixRotationQuaternion ( (D3DXMATRIX *)&g_rot_matrix, (D3DXQUATERNION *)in_end );
D3DXVec3Transform ( (D3DXVECTOR4 *)g_after_end, (D3DXVECTOR3 *)g_unit_x, (D3DXMATRIX *)&g_rot_matrix );
g_inter [0] = g_after_start [0] + ( g_after_end [0] - g_after_start [0] ) * in_disp;
g_inter [1] = g_after_start [1] + ( g_after_end [1] - g_after_start [1] ) * in_disp;
g_inter [2] = g_after_start [2] + ( g_after_end [2] - g_after_start [2] ) * in_disp;
if ( VectorLength ( g_inter ) < error )
D3DXQuaternionIdentity ( (D3DXQUATERNION *)out_quat );
else
{
D3DXVec3Normalize ( (D3DXVECTOR3 *)g_inter, (D3DXVECTOR3 *)g_inter );
BuildQuaternion ( g_unit_x, g_inter, out_quat );
}
return;
}
void FX_CAnim::SetEOPFrame ()
{
int index, subindex;
if ( m_eopframe >= ANIM_FRAME_ERROR_VALUE )
return;
float desiredFrame = m_eopframe + FX_ANIM_ERROR;
TRACK *thisTrack;
for ( index = 0; \
index < m_iNumTrack; \
++index )
{
thisTrack = &m_Tracks [index];
for ( subindex = 0; \
subindex < thisTrack ->iNumKeyframe; \
++subindex )
{
if ( desiredFrame < thisTrack ->pKeyframe [subindex].frame )
break;
}
m_eopframeIdx [index] = subindex - 1;
}
return;
}
void FX_CAnim::SetEOAFrame ()
{
int index, subindex;
if ( m_eoaframe < 0 )
return;
float desiredFrame = m_eoaframe + FX_ANIM_ERROR;
TRACK *thisTrack;
for ( index = 0; \
index < m_iNumTrack; \
++index )
{
thisTrack = &m_Tracks [index];
for ( subindex = 0; \
subindex < thisTrack ->iNumKeyframe; \
++subindex )
{
if ( desiredFrame < thisTrack ->pKeyframe [subindex].frame )
break;
}
m_eoaframeIdx [index] = subindex - 1;
}
return;
}
void FX_CAnim::SetComboStart ( Fx_CHARACTER_t* in_char )
{
float speedFactor = in_char ->ani_curSpeed * m_timePerFrame;
memcpy( in_char ->key_curIndex, m_eopframeIdx, sizeof(int) * m_iNumTrack );
in_char ->ani_elapsed = m_eopframe * speedFactor;
if ( in_char ->flag_useRHandAura )
{
in_char ->ren_auraRHandData.nextUpdate = in_char ->ani_elapsed - FX_ANIM_ERROR;
}
if ( in_char ->flag_useLHandAura )
{
in_char ->ren_auraLHandData.nextUpdate = in_char ->ani_elapsed - FX_ANIM_ERROR;
}
return;
}
float FX_CAnim::GetInitialRadius ()
{
vec3_t subtract;
vec3_t min;
vec3_t max;
min [0] = m_boundBox [0][0];
min [1] = m_boundBox [0][1];
min [2] = 0.0f;
max [0] = m_boundBox [0][3];
max [1] = m_boundBox [0][4];
max [2] = 0.0f;
VectorSubtract ( subtract, max, min );
return ( VectorLength ( subtract ) * 0.5f );
}
| C++ |
#ifndef _MESH_H_HF02HF23H03HESKJDSJ12EF
#define _MESH_H_HF02HF23H03HESKJDSJ12EF
#define MAX_IMAGEMAP 8
#define MAX_VERTEXCOLOR 4
#define SIZE_MESH_FILENAME 256
#define NORMAL_LENGTH_MULTIPLIER 3.0f
#define MAX_MESHES 5
typedef struct
{
int iBoneID;
float fWeight;
D3DXQUATERNION quatPos;
D3DXQUATERNION quatNormal;
} BONEINFLUENCE;
typedef struct
{
UINT iNumBoneInfluences;
BONEINFLUENCE* boneInfluences;
} INFLUENCE;
typedef struct
{
D3DXCOLOR clrAmbient;
D3DXCOLOR clrDiffuse;
D3DXCOLOR clrSpecular;
FLOAT fShininess;
} MATERIAL;
typedef struct
{
FLOAT tu;
FLOAT tv;
} TEXCOORD;
typedef struct
{
INT iVertexID;
D3DXCOLOR clrVertexColor;
TEXCOORD VertexTC [MAX_IMAGEMAP];
} VERTEXMAP;
typedef struct
{
WORD index [3];
} FACEINDEX;
typedef struct
{
MATERIAL material;
int iNumImageMap;
int iImageMaps [MAX_IMAGEMAP];
int iNumFace;
FACEINDEX *faceLists;
int iNumVertexMap;
int iNumVertexColor;
VERTEXMAP *vertexMaps;
vec3_t bound_min;
vec3_t bound_max;
int numBoundPlanes;
} MESHCHUNK;
typedef struct
{
int numVertices;
INFLUENCE *influences;
MESHCHUNK *meshchunk;
} MESH_t;
class FX_CMesh
{
public:
FX_CMesh () {};
~FX_CMesh();
public:
char m_strFileName[SIZE_MESH_FILENAME];
char m_strMeshName[64];
int m_iNumLODMesh;
MESH_t m_meshes [MAX_MESHES];
char m_strDesc [256];
FX_BONESTRUCT_ID m_pBoneStID;
MESHINFO_t m_pMeshInfo;
LPDIRECT3DDEVICE8 m_lpD3DDevice;
DWORD m_dwNumVertices;
DWORD m_dwNumIndices;
DWORD m_dwNumNormalVertices;
int m_fileVersion;
public:
VOID Initialize ( LPDIRECT3DDEVICE8 lpD3DDevice );
virtual HRESULT RestoreDeviceObjects();
virtual VOID PreRenderSetting() {};
virtual VOID PostRenderSetting() {};
virtual VOID Clear();
virtual bool LoadData( TCHAR *strFilename,
CFileMng *fileMng );
void LoadLODMeshes ( BYTE *in_buffer,
int offset );
VOID DeleteThis();
void Cleanup();
};
#endif | C++ |
#ifndef _ANIMATION_H_JKH2480HF27G0H90H02398
#define _ANIMATION_H_JKH2480HF27G0H90H02398
class FX_CAnim
{
public:
FX_CAnim ();
~FX_CAnim ();
public:
int m_iNumTrack;
TRACK *m_Tracks;
bboxf_t *m_boundBox;
FX_CSkel *m_pSkeleton;
float m_fCurrentTime;
DWORD m_dwNumVertices;
DWORD m_dwNumIndices;
TRACK *m_ThisTrack;
int m_iCurFrame;
int m_iNextFrame;
int m_iReturnValue;
int m_iBoneID;
char m_strDesc [256];
FX_BONESTRUCT_ID m_pBoneStID;
int m_totalFrames;
float m_timePerFrame;
float m_framePerTime;
float m_totalTime;
float m_rcptotalTime;
ANIM_PROPERTY_t m_animProperty;
int *m_eopframeIdx;
int *m_eoaframeIdx;
float m_eopframe;
float m_eoaframe;
float m_initialHeight;
int m_fileVersion;
public:
bool Clear ();
bool LoadData( TCHAR *strFilename,
CFileMng *fileMng );
void Cleanup();
HRESULT Interpolate ( const KEYFRAME *prevKeyframe, const KEYFRAME *nextKeyframe, const float in_displacement, KEYFRAME *result );
void MakeInterpolatedVertices ( Fx_CHARACTER_t *in_char, const int in_ended );
int CheckKeyframeState ( Fx_CHARACTER_t *in_char, const int in_option );
void StartNewAnim ();
void TransformKeyframes ( Fx_CHARACTER_t *in_char );
void QuatInterpolate ( vec4_t out_quat, const vec4_t in_start, const vec4_t in_end, const float disp );
void SetEOPFrame ();
void SetEOAFrame ();
void SetComboStart ( Fx_CHARACTER_t* in_char );
inline float GetInitialHeight () { return m_Tracks [0].pKeyframe [0].vecOffset [2]; };
inline float GetInitialTall () { return ( m_boundBox [0][5] - m_boundBox [0][2] ); };
float GetInitialRadius ();
};
#endif
| C++ |
#include "../../global_def.h"
#include "../Common.h"
int g_allocatedMemory;
FX_CMesh::~FX_CMesh()
{
}
VOID FX_CMesh::Initialize ( LPDIRECT3DDEVICE8 lpD3DDevice )
{
m_lpD3DDevice = lpD3DDevice;
memset ( &m_meshes, 0, sizeof (m_meshes) );
m_dwNumNormalVertices = 0;
return;
}
VOID FX_CMesh::Clear ()
{
int index, subindex;
MESH_t *thisMesh = &m_meshes [0];
for ( index = 0; \
index < m_iNumLODMesh + 1; \
++index, ++thisMesh )
{
for ( subindex = 0; \
subindex < thisMesh ->numVertices; \
++subindex )
{
GTH_SAFE_DELETE ( thisMesh ->influences [subindex].boneInfluences );
}
GTH_SAFE_DELETE_ARRAY ( thisMesh ->influences );
GTH_SAFE_DELETE_ARRAY ( thisMesh ->meshchunk ->faceLists );
GTH_SAFE_DELETE_ARRAY ( thisMesh ->meshchunk ->vertexMaps );
GTH_SAFE_DELETE_ARRAY ( thisMesh ->meshchunk );
}
return;
}
bool FX_CMesh::LoadData ( TCHAR *strFilename,
CFileMng *fileMng )
{
strcpy ( m_strFileName, strFilename );
if ( !m_strFileName )
{
return FALSE;
}
int fileSize;
BYTE *pFileBuffer;
int offset = 0;
pFileBuffer = fileMng->ReadFileFromPack ( strFilename );
fileSize = (int)fileMng ->GetFileSizeFromPack ( strFilename );
g_allocatedMemory = 0;
#define __CALC_ALLOCATED_MEMORY(a) if( g_resCounter->Enabled() ) { g_allocatedMemory += (a); }
char version [MAX_PATH];
GetDataFromBuffer ( (void *)version, pFileBuffer, strlen("VERSION"), offset );
version [strlen("VERSION")] = NULL;
if ( strcmp ( version, "VERSION" ) )
{
m_fileVersion = 100;
offset = 4;
}
else
{
GetDataFromBuffer ( (void *)version, pFileBuffer, 3, offset );
version [3] = NULL;
m_fileVersion = atoi ( version );
if ( m_fileVersion < 100 )
{
m_fileVersion = 100;
}
GetDataFromBuffer ( (void *)version, pFileBuffer, 4, offset );
version [4] = NULL;
if ( strcmp ( version, "MESH" ) )
{
}
}
int iDescLength;
GetDataFromBuffer ( (void *)&iDescLength,
pFileBuffer,
sizeof(int),
offset );
GetDataFromBuffer ( (void *)m_strDesc,
pFileBuffer,
iDescLength,
offset );
m_strDesc [iDescLength] = '\0';
GetDataFromBuffer ( (void *)&m_pMeshInfo,
pFileBuffer,
sizeof(MESHINFO_t),
offset );
GetDataFromBuffer ( (void *)&m_pBoneStID,
pFileBuffer,
sizeof(FX_BONESTRUCT_ID),
offset );
INT iMeshNameCount;
GetDataFromBuffer ( (void *)&iMeshNameCount,
pFileBuffer,
sizeof(int),
offset );
GetDataFromBuffer ( (void *)m_strMeshName,
pFileBuffer,
iMeshNameCount,
offset );
m_strMeshName [iMeshNameCount] = '\0';
GetDataFromBuffer ( (void *)&m_meshes [0].numVertices,
pFileBuffer,
sizeof(int),
offset );
m_meshes [0].influences = new INFLUENCE [m_meshes [0].numVertices];
__CALC_ALLOCATED_MEMORY( sizeof(INFLUENCE) * m_meshes[ 0 ].numVertices - sizeof(INFLUENCE*) )
UINT iTemp;
GetDataFromBuffer ( (void *)&iTemp,
pFileBuffer,
sizeof(int),
offset );
UINT iNumMesh;
GetDataFromBuffer ( (void *)&iNumMesh,
pFileBuffer,
sizeof(UINT),
offset );
m_meshes [0].meshchunk = new MESHCHUNK;
__CALC_ALLOCATED_MEMORY( sizeof(MESHCHUNK) - sizeof(MESHCHUNK*) )
for ( int iInfluenceID = 0;
iInfluenceID < m_meshes [0].numVertices;
++iInfluenceID
)
{
INFLUENCE* pInfluenceInst;
pInfluenceInst = &m_meshes [0].influences [iInfluenceID];
GetDataFromBuffer ( (void *)&pInfluenceInst->iNumBoneInfluences,
pFileBuffer,
sizeof(UINT),
offset );
if ( pInfluenceInst->iNumBoneInfluences > 0 )
{
pInfluenceInst->boneInfluences = new BONEINFLUENCE [pInfluenceInst->iNumBoneInfluences];
__CALC_ALLOCATED_MEMORY( sizeof(BONEINFLUENCE) * pInfluenceInst->iNumBoneInfluences - sizeof(BONEINFLUENCE*) )
}
else
pInfluenceInst->boneInfluences = NULL;
GetDataFromBuffer ( (void *)&pInfluenceInst->boneInfluences [0],
pFileBuffer,
sizeof (BONEINFLUENCE) * pInfluenceInst->iNumBoneInfluences,
offset );
}
MESHCHUNK* pBipedMeshInst;
pBipedMeshInst = m_meshes [0].meshchunk;
GetDataFromBuffer ( (void *)&pBipedMeshInst->material,
pFileBuffer,
sizeof(MATERIAL),
offset );
GetDataFromBuffer ( (void *)&pBipedMeshInst->iNumImageMap,
pFileBuffer,
sizeof(UINT),
offset );
GetDataFromBuffer ( (void *)&pBipedMeshInst->iImageMaps [0],
pFileBuffer,
sizeof (int) * pBipedMeshInst->iNumImageMap,
offset );
GetDataFromBuffer ( (void *)&pBipedMeshInst->iNumFace,
pFileBuffer,
sizeof(UINT),
offset );
pBipedMeshInst->faceLists = new FACEINDEX [pBipedMeshInst->iNumFace];
__CALC_ALLOCATED_MEMORY( sizeof(FACEINDEX) * pBipedMeshInst->iNumFace - sizeof(FACEINDEX*) )
GetDataFromBuffer ( (void *)&pBipedMeshInst->faceLists [0],
pFileBuffer,
sizeof (FACEINDEX) * pBipedMeshInst->iNumFace,
offset );
GetDataFromBuffer ( (void *)&pBipedMeshInst->iNumVertexMap,
pFileBuffer,
sizeof(UINT),
offset );
pBipedMeshInst->vertexMaps = new VERTEXMAP [pBipedMeshInst->iNumVertexMap];
__CALC_ALLOCATED_MEMORY( sizeof(VERTEXMAP) * pBipedMeshInst->iNumVertexMap - sizeof(VERTEXMAP*) )
GetDataFromBuffer ( (void *)&pBipedMeshInst->iNumVertexColor,
pFileBuffer,
sizeof(UINT),
offset );
for ( int iVertexID = 0;
iVertexID < pBipedMeshInst->iNumVertexMap;
++iVertexID
)
{
VERTEXMAP* pVertexMapInst;
pVertexMapInst = &pBipedMeshInst->vertexMaps [iVertexID];
GetDataFromBuffer ( (void *)&pVertexMapInst->iVertexID,
pFileBuffer,
sizeof(int),
offset );
if ( pBipedMeshInst->iNumVertexColor > 0 )
{
GetDataFromBuffer ( (void *)&pVertexMapInst->clrVertexColor,
pFileBuffer,
sizeof(D3DXCOLOR),
offset );
}
GetDataFromBuffer ( (void *)&pVertexMapInst->VertexTC [0],
pFileBuffer,
sizeof (TEXCOORD) * pBipedMeshInst->iNumImageMap,
offset );
}
GetDataFromBuffer ( (void *)&m_meshes [0].meshchunk ->bound_min,
pFileBuffer,
sizeof (vec3_t),
offset );
GetDataFromBuffer ( (void *)&m_meshes [0].meshchunk ->bound_max,
pFileBuffer,
sizeof (vec3_t),
offset );
if ( fileSize <= offset )
{
m_iNumLODMesh = 0;
}
else
{
GetDataFromBuffer ( (void *)&m_iNumLODMesh,
pFileBuffer,
sizeof (int),
offset );
LoadLODMeshes ( pFileBuffer, offset );
}
GTH_SAFE_FREE ( pFileBuffer );
__CALC_ALLOCATED_MEMORY( sizeof(FX_CMesh) - sizeof(FX_CMesh*) )
if ( g_resCounter->Enabled() )
{
char *lowercase = _strlwr( _strdup( strFilename ) );
if ( strstr( lowercase, "mon" ) )
{
g_resCounter->Add_DataType( RESCOUNTER_MESH_CHAR_MONSTER, g_allocatedMemory );
}
else if ( strstr( lowercase, "ava" ) )
{
g_resCounter->Add_DataType( RESCOUNTER_MESH_CHAR_PC, g_allocatedMemory );
}
else if ( strstr( lowercase, "npc" ) )
{
g_resCounter->Add_DataType( RESCOUNTER_MESH_CHAR_NPC, g_allocatedMemory );
}
free( lowercase );
}
return TRUE;
}
void FX_CMesh::LoadLODMeshes ( BYTE *in_buffer,
int offset )
{
int index;
for ( index = 1; \
index < ( 1 + m_iNumLODMesh ); \
++index )
{
GetDataFromBuffer ( (void *)&m_meshes [index].numVertices,
in_buffer,
sizeof(int),
offset );
GetDataFromBuffer ( (void *)&m_meshes [index].numVertices,
in_buffer,
sizeof(int) * 2,
offset );
for ( int iInfluenceID = 0;
iInfluenceID < m_meshes [index].numVertices;
++iInfluenceID
)
{
INFLUENCE *pInfluenceInst;
pInfluenceInst = &m_meshes [index].influences [iInfluenceID];
GetDataFromBuffer ( (void *)&pInfluenceInst->iNumBoneInfluences,
in_buffer,
sizeof(UINT),
offset );
if ( pInfluenceInst->iNumBoneInfluences > 0 )
{
pInfluenceInst->boneInfluences = new BONEINFLUENCE [pInfluenceInst->iNumBoneInfluences];
__CALC_ALLOCATED_MEMORY( sizeof(BONEINFLUENCE) * pInfluenceInst->iNumBoneInfluences - sizeof(BONEINFLUENCE*) )
}
else
pInfluenceInst->boneInfluences = NULL;
GetDataFromBuffer ( (void *)&pInfluenceInst->boneInfluences [0],
in_buffer,
sizeof (BONEINFLUENCE) * pInfluenceInst->iNumBoneInfluences,
offset );
}
MESHCHUNK* pBipedMeshInst;
pBipedMeshInst = m_meshes [index].meshchunk;
GetDataFromBuffer ( (void *)&pBipedMeshInst->material,
in_buffer,
sizeof(MATERIAL),
offset );
GetDataFromBuffer ( (void *)&pBipedMeshInst->iNumImageMap,
in_buffer,
sizeof(UINT),
offset );
GetDataFromBuffer ( (void *)&pBipedMeshInst->iImageMaps [0],
in_buffer,
sizeof (int) * pBipedMeshInst->iNumImageMap,
offset );
GetDataFromBuffer ( (void *)&pBipedMeshInst->iNumFace,
in_buffer,
sizeof(UINT),
offset );
pBipedMeshInst->faceLists = new FACEINDEX [pBipedMeshInst->iNumFace];
__CALC_ALLOCATED_MEMORY( sizeof(FACEINDEX) * pBipedMeshInst->iNumFace - sizeof(FACEINDEX*) )
GetDataFromBuffer ( (void *)&pBipedMeshInst->faceLists [0],
in_buffer,
sizeof (FACEINDEX) * pBipedMeshInst->iNumFace,
offset );
GetDataFromBuffer ( (void *)&pBipedMeshInst->iNumVertexMap,
in_buffer,
sizeof(UINT),
offset );
pBipedMeshInst->vertexMaps = new VERTEXMAP [pBipedMeshInst->iNumVertexMap];
__CALC_ALLOCATED_MEMORY( sizeof(VERTEXMAP) * pBipedMeshInst->iNumVertexMap - sizeof(VERTEXMAP*) )
GetDataFromBuffer ( (void *)&pBipedMeshInst->iNumVertexColor,
in_buffer,
sizeof(UINT),
offset );
for ( int iVertexID = 0;
iVertexID < pBipedMeshInst->iNumVertexMap;
++iVertexID
)
{
VERTEXMAP* pVertexMapInst;
pVertexMapInst = &pBipedMeshInst->vertexMaps [iVertexID];
GetDataFromBuffer ( (void *)&pVertexMapInst->iVertexID,
in_buffer,
sizeof(int),
offset );
if ( pBipedMeshInst->iNumVertexColor > 0 )
{
GetDataFromBuffer ( (void *)&pVertexMapInst->clrVertexColor,
in_buffer,
sizeof(D3DXCOLOR),
offset );
}
GetDataFromBuffer ( (void *)&pVertexMapInst->VertexTC [0],
in_buffer,
sizeof (TEXCOORD) * pBipedMeshInst->iNumImageMap,
offset );
}
GetDataFromBuffer ( (void *)&m_meshes [index].meshchunk ->bound_min,
in_buffer,
sizeof (vec3_t),
offset );
GetDataFromBuffer ( (void *)&m_meshes [index].meshchunk ->bound_max,
in_buffer,
sizeof (vec3_t),
offset );
}
return;
}
HRESULT FX_CMesh::RestoreDeviceObjects ()
{
return S_OK;
}
void FX_CMesh::Cleanup()
{
int index, subindex;
MESH_t *thisMesh = &m_meshes [0];
for ( index = 0; \
index < m_iNumLODMesh + 1; \
++index, ++thisMesh )
{
for ( subindex = 0; \
subindex < thisMesh ->numVertices; \
++subindex )
{
GTH_SAFE_DELETE ( thisMesh ->influences [subindex].boneInfluences );
}
GTH_SAFE_DELETE_ARRAY ( thisMesh ->influences );
GTH_SAFE_DELETE_ARRAY ( thisMesh ->meshchunk ->faceLists );
GTH_SAFE_DELETE_ARRAY ( thisMesh ->meshchunk ->vertexMaps );
GTH_SAFE_DELETE_ARRAY ( thisMesh ->meshchunk );
}
return;
} | C++ |
#ifndef _UTILITIES_H_IJF02J023J03JH0AH0D9H3_
#define _UTILITIES_H_IJF02J023J03JH0AH0D9H3_
typedef struct
{
char strName [32];
int iIndex;
char szParentName [32];
} stTAGINFO;
typedef struct
{
TCHAR strName[32];
INT iIndex;
} stMESHINFO;
typedef struct
{
char name [32];
int index;
} BONEINFO_t;
#define DXVectorSet3( a, b, c, d ) ( (a).x = (b), (a).y = (c), (a).z = (d) )
#define DXVectorSet4( a, b, c, d, e ) ( (a).x = (b), (a).y = (c), (a).z = (d), (a).w = (e) )
class CMeshManager
{
public:
CMeshManager() {};
virtual ~CMeshManager() {};
protected:
stMESHINFO* m_aMeshInfo;
INT m_iMeshCount;
CScript *m_pScript;
public:
bool Load ( TCHAR *strFilename );
int GetIndex ( char *pszMeshName );
INT GetSize ();
TCHAR* GetName ( const INT iMeshIndex );
void Cleanup ();
void SetScript ( CScript *script ) { m_pScript = script; }
};
class FX_CBoneManager
{
public:
FX_CBoneManager() {};
~FX_CBoneManager() {};
public:
BONEINFO_t *m_BoneInfos;
int m_iBoneCount;
CScript *m_pScript;
public:
bool Load ( char *pszFileName );
int GetIndex ( char *pszBoneName );
char* GetName ( const int iBoneIndex );
void Cleanup ();
void SetScript ( CScript *script ) { m_pScript = script; }
};
#define FX_NUM_TRI 3600
class FX_CMathTbl
{
public:
FX_CMathTbl () {};
~FX_CMathTbl () {};
public:
float m_sin [FX_NUM_TRI];
float m_cos [FX_NUM_TRI];
CFileMng *m_fileMng;
public:
void Load ();
void SetFileManager ( CFileMng *fileMng ) { m_fileMng = fileMng; }
};
class FX_CCharUtil
{
public:
FX_CCharUtil () {};
~FX_CCharUtil () {};
public:
CScript *m_pScript;
CFileMng *m_fileMng;
FX_CMathTbl *m_mathtbl;
public:
void SetFileManager ( CFileMng *fileMng ) { m_fileMng = fileMng; }
void SetScript ( CScript *script ) { m_pScript = script; }
void SetMathTbl ( FX_CMathTbl *mathtbl ) { m_mathtbl = mathtbl; }
void TransformBBox ( const bboxf_t &in_bound, const float in_yaw, const float in_roll, const vec3_t in_pos,
bboxf_t &out_bound );
void TransformBBoxByCamera ( const bboxf_t &in_bound, const float in_yaw, const float in_camera_yaw,
const float in_camera_pitch, const vec3_t in_pos, bboxf_t &out_bound );
void RemoveExtension ( char *in_source, char *out_dest );
void TransformVertexForBBox ( const float *in_vec, const float sinval, const float cosval, float *out_vec );
int MakeAngleWithTime ( const float in_time,
const float in_vel );
};
#ifdef _FXDEBUG
#define CHECKERROR(cond, message) \
if ( cond ) { ShowError ( message, __FILE__, __LINE__ ); exit (0); }
#endif
void ShowError ( const char *pszText, const char *pszFileName, const int line );
void ShowDXError ( const HRESULT hr, const char *pszFileName, const int line );
void ShowMessage ( const char *pszTitle, const char *pszMessage, const char *pszFileName, const int line );
void GetDataFromBuffer ( void *out, const BYTE *buffer, const int size, int &count );
void BuildQuaternion ( const vec3_t in_base,
const vec3_t in_vector,
vec4_t out_quat );
inline void Fx_Quat2Multiply ( vec4_t qResult,
const vec4_t q2,
const vec4_t q1 )
{
qResult [0] = q1 [0]*q2 [3] + q1 [1]*q2 [2] - q1 [2]*q2 [1] + q1 [3]*q2 [0];
qResult [1] = - q1 [0]*q2 [2] + q1 [1]*q2 [3] + q1 [2]*q2 [0] + q1 [3]*q2 [1];
qResult [2] = q1 [0]*q2 [1] - q1 [1]*q2 [0] + q1 [2]*q2 [3] + q1 [3]*q2 [2];
qResult [3] = - q1 [0]*q2 [0] - q1 [1]*q2 [1] - q1 [2]*q2 [2] + q1 [3]*q2 [3];
return;
};
inline void Fx_Quat3Multiply ( vec4_t qResult,
vec4_t qBuffer,
const vec4_t q1,
const vec4_t q2,
const vec4_t q3 )
{
Fx_Quat2Multiply ( qBuffer, q1, q2 );
Fx_Quat2Multiply ( qResult, qBuffer, q3 );
return;
}
void FX_CatmullRomMulti ( DIFFUSETEXVERTEX *out_pt,
const vec3_t in_first,
const vec3_t in_firstctrl,
const vec3_t in_second,
const vec3_t in_secondctrl,
int in_numpoints );
void InverseRigidTransform ( matrix4x4_t *in_source, matrix4x4_t *out_dest );
void FastSlerp ( D3DXQUATERNION *out_quat,
D3DXQUATERNION *in_first,
D3DXQUATERNION *in_second,
const float in_disp );
void SaveCurrentCharacterState ( Fx_CHARACTER_t *in_char );
#endif
| C++ |
#include "../../global_def.h"
#include "../Common.h"
bool g_bResult;
HRESULT g_hr;
char g_szTemp[512];
#define param1 GLOBAL_VEC3_1
#define param2 GLOBAL_VEC3_2
#define param3 GLOBAL_VEC3_3
#define param4 GLOBAL_VEC3_4
#define g_nVector GLOBAL_VEC3_1
bool CMeshManager::Load ( TCHAR *strFileName )
{
m_pScript->Load ( strFileName );
m_pScript->BeginParse();
m_iMeshCount = atoi ( m_pScript->GetNextToken() );
m_aMeshInfo = new stMESHINFO [m_iMeshCount];
for ( int index = 0;
index < m_iMeshCount;
++index )
{
strcpy ( m_aMeshInfo [index] .strName,
m_pScript->GetNextToken() );
m_aMeshInfo [index] .iIndex = atoi ( m_pScript->GetNextToken() );
}
char *pszTemp;
pszTemp = m_pScript->GetNextToken();
if ( stricmp ( pszTemp, "EOF" ) != 0 )
{
ShowError ( "Mesh count doesn't match the actual data!", __FILE__, __LINE__ );
return false;
}
return true;
}
int CMeshManager::GetIndex( char *pszMeshName )
{
for ( int index = 0;
index < m_iMeshCount;
++index )
{
if ( _stricmp ( pszMeshName,
m_aMeshInfo [index] .strName ) == 0
)
{
return m_aMeshInfo [index] .iIndex;
}
}
ShowError ( _T ("Failed to find matching tag! Please check tag info file!"),
__FILE__,
__LINE__ );
return -1;
}
INT CMeshManager::GetSize ()
{
return m_iMeshCount;
}
TCHAR* CMeshManager::GetName ( const INT iMeshIndex )
{
if ( ( iMeshIndex < 0 ) ||
( iMeshIndex >= m_iMeshCount)
)
{
ShowError ( _T ("Mesh index value is invalid!"),
__FILE__,
__LINE__ );
return NULL;
}
for ( int index = 0;
index < m_iMeshCount;
++index )
{
if ( iMeshIndex == m_aMeshInfo [index] .iIndex )
return m_aMeshInfo [index] .strName;
}
ShowError ( _T ("There's no matching Mesh! Please check Mesh info file!"),
__FILE__,
__LINE__ );
return NULL;
}
VOID CMeshManager::Cleanup ()
{
GTH_SAFE_DELETE_ARRAY ( m_aMeshInfo );
return;
}
bool FX_CBoneManager::Load ( char *pszFileName )
{
m_pScript ->Load ( pszFileName );
m_pScript ->BeginParse ();
m_iBoneCount = atoi ( m_pScript ->GetNextToken () );
m_BoneInfos = new BONEINFO_t [m_iBoneCount];
for ( int index = 0;
index < m_iBoneCount;
++index )
{
strcpy ( m_BoneInfos [index] .name,
m_pScript->GetNextToken() );
m_BoneInfos [index] .index = atoi ( m_pScript->GetNextToken() );
}
char *pszTemp;
pszTemp = m_pScript->GetNextToken();
if ( stricmp ( pszTemp, "EOF" ) != 0 )
{
ShowError ( "Mesh count doesn't match the actual data!", __FILE__, __LINE__ );
return false;
}
return true;
}
int FX_CBoneManager::GetIndex ( char *pszBoneName )
{
for ( int index = 0;
index < m_iBoneCount;
++index )
{
if ( _stricmp ( pszBoneName,
m_BoneInfos [index] .name ) == 0
)
{
return m_BoneInfos [index] .index;
}
}
ShowError ( _T ("Failed to find matching tag! Please check tag info file!"),
__FILE__,
__LINE__ );
return -1;
}
char* FX_CBoneManager::GetName ( const int iBoneIndex )
{
if ( ( iBoneIndex < 0 ) ||
( iBoneIndex >= m_iBoneCount)
)
{
ShowError ( _T ("Mesh index value is invalid!"),
__FILE__,
__LINE__ );
return NULL;
}
for ( int index = 0;
index < m_iBoneCount;
++index )
{
if ( iBoneIndex == m_BoneInfos [index] .index )
return m_BoneInfos [index] .name;
}
ShowError ( _T ("There's no matching Mesh! Please check Mesh info file!"),
__FILE__,
__LINE__ );
return NULL;
}
void FX_CBoneManager::Cleanup ()
{
GTH_SAFE_DELETE_ARRAY ( m_BoneInfos );
}
void FX_CMathTbl::Load ()
{
BYTE *pFileBuffer;
int offset = 0, num;
pFileBuffer = m_fileMng->ReadFileFromPack ( FILENAME_SIN_TABLE );
GetDataFromBuffer ( (void *)&num, pFileBuffer, sizeof (int), offset );
if ( num != FX_NUM_TRI )
ShowError ( TEXT ("FX_CMathTbl: array num & table num mismatch!"),
__FILE__, __LINE__ );
GetDataFromBuffer ( (void *)&m_sin, pFileBuffer, sizeof(float) * FX_NUM_TRI, offset );
GTH_SAFE_FREE ( pFileBuffer );
offset = 0;
pFileBuffer = m_fileMng->ReadFileFromPack ( FILENAME_COS_TABLE );
GetDataFromBuffer ( (void *)&num, pFileBuffer, sizeof (int), offset );
if ( num != FX_NUM_TRI )
ShowError ( TEXT ("FX_CMathTbl: array num & table num mismatch!"),
__FILE__, __LINE__ );
GetDataFromBuffer ( (void *)&m_cos, pFileBuffer, sizeof(float) * FX_NUM_TRI, offset );
GTH_SAFE_FREE ( pFileBuffer );
return;
}
void ShowError ( const char *pszText,
const char *pszFileName,
const int line )
{
TCHAR szError [512];
sprintf ( szError, "%s\nFile : %s\nLine : %d",
pszText, pszFileName, line );
MessageBox ( NULL, szError, "Error!", MB_OK );
}
void ShowDXError ( const HRESULT hr,
const char *pszFileName,
const int line )
{
char szDXError[256];
char szError[512];
D3DXGetErrorString ( hr,
szDXError,
256 );
sprintf ( szError,
"%s\nFile : %s\nLine : %d",
szDXError, pszFileName, line );
MessageBox ( NULL,
szError,
"DX Error!",
MB_OK );
}
void ShowMessage ( const char *pszTitle,
const char *pszMessage,
const char *pszFileName,
const int line )
{
TCHAR szMessage[512];
sprintf ( szMessage,
"%s\nFile : %s\nLine : %d",
pszMessage, pszFileName, line );
MessageBox( NULL, szMessage, pszTitle, MB_OK );
}
void GetDataFromBuffer ( void *out,
const BYTE *buffer,
const int size,
int &count )
{
memcpy ( out,
buffer + count,
size );
count += size;
return;
}
void FX_CCharUtil::TransformBBox ( const bboxf_t &in_bound,
const float in_yaw,
const float in_roll,
const vec3_t in_pos,
bboxf_t &out_bound )
{
float sinval;
float cosval;
float minx, maxx, miny, maxy;
float minyy, maxyy, minz, maxz;
int index;
float point_x [4];
float outpt [8];
if ( in_yaw != 0.0f )
{
point_x [0] = in_bound [0];
point_x [1] = in_bound [3];
point_x [2] = in_bound [1];
point_x [3] = in_bound [4];
sinval = (float)sin (in_yaw);
cosval = (float)cos (in_yaw);
TransformVertexForBBox ( point_x, sinval, cosval, outpt );
minx = outpt [0];
maxx = outpt [0];
for ( index = 1; \
index < 4; \
++index )
{
if ( minx > outpt [index] )
minx = outpt [index];
if ( maxx < outpt [index] )
maxx = outpt [index];
}
miny = outpt [4];
maxy = outpt [4];
for ( index = 5; \
index < 8; \
++index )
{
if ( miny > outpt [index] )
miny = outpt [index];
if ( maxy < outpt [index] )
maxy = outpt [index];
}
}
else
{
minx = in_bound [0];
maxx = in_bound [3];
miny = in_bound [1];
maxy = in_bound [4];
}
if ( in_roll != 0.0f )
{
point_x [0] = miny;
point_x [1] = maxy;
point_x [2] = in_bound [2];
point_x [3] = in_bound [5];
sinval = (float)sin (in_roll);
cosval = (float)cos (in_roll);
TransformVertexForBBox ( point_x, sinval, cosval, outpt );
minyy = outpt [0];
maxyy = outpt [0];
for ( index = 1; \
index < 4; \
++index )
{
if ( minyy > outpt [index] )
minyy = outpt [index];
if ( maxyy < outpt [index] )
maxyy = outpt [index];
}
minz = outpt [4];
maxz = outpt [4];
for ( index = 5; \
index < 8; \
++index )
{
if ( minz > outpt [index] )
minz = outpt [index];
if ( maxz < outpt [index] )
maxz = outpt [index];
}
}
else
{
minyy = in_bound [1];
maxyy = in_bound [4];
minz = in_bound [2];
maxz = in_bound [5];
}
out_bound [0] = minx + in_pos [0];
out_bound [1] = miny + in_pos [1];
out_bound [2] = minz + in_pos [2];
out_bound [3] = maxx + in_pos [0];
out_bound [4] = maxy + in_pos [1];
out_bound [5] = maxz + in_pos [2];
return;
}
void FX_CCharUtil::TransformBBoxByCamera ( const bboxf_t &in_bound,
const float in_yaw,
const float in_camera_yaw,
const float in_camera_pitch,
const vec3_t in_pos,
bboxf_t &out_bound )
{
float sinval;
float cosval;
float minx, maxx, miny, maxy;
float minyy, maxyy, minz, maxz;
int index;
float point_x [4];
float outpt [8];
if ( in_yaw != 0.0f )
{
point_x [0] = in_bound [0];
point_x [1] = in_bound [3];
point_x [2] = in_bound [1];
point_x [3] = in_bound [4];
sinval = (float)sin (in_yaw);
cosval = (float)cos (in_yaw);
TransformVertexForBBox ( point_x, sinval, cosval, outpt );
minx = outpt [0];
maxx = outpt [0];
for ( index = 1; \
index < 4; \
++index )
{
if ( minx > outpt [index] )
minx = outpt [index];
if ( maxx < outpt [index] )
maxx = outpt [index];
}
miny = outpt [4];
maxy = outpt [4];
for ( index = 5; \
index < 8; \
++index )
{
if ( miny > outpt [index] )
miny = outpt [index];
if ( maxy < outpt [index] )
maxy = outpt [index];
}
}
else
{
minx = in_bound [0];
maxx = in_bound [3];
miny = in_bound [1];
maxy = in_bound [4];
}
if ( in_camera_yaw != 0.0f )
{
point_x [0] = minx;
point_x [1] = maxx;
point_x [2] = miny;
point_x [3] = maxy;
sinval = (float)sin (in_camera_yaw);
cosval = (float)cos (in_camera_yaw);
TransformVertexForBBox ( point_x, sinval, cosval, outpt );
minx = outpt [0];
maxx = outpt [0];
for ( index = 1; \
index < 4; \
++index )
{
if ( minx > outpt [index] )
minx = outpt [index];
if ( maxx < outpt [index] )
maxx = outpt [index];
}
miny = outpt [4];
maxy = outpt [4];
for ( index = 5; \
index < 8; \
++index )
{
if ( miny > outpt [index] )
miny = outpt [index];
if ( maxy < outpt [index] )
maxy = outpt [index];
}
}
if ( in_camera_pitch != 0.0f )
{
point_x [0] = miny;
point_x [1] = maxy;
point_x [2] = in_bound [2];
point_x [3] = in_bound [5];
sinval = (float)sin (in_camera_pitch);
cosval = (float)cos (in_camera_pitch);
TransformVertexForBBox ( point_x, sinval, cosval, outpt );
minyy = outpt [0];
maxyy = outpt [0];
for ( index = 1; \
index < 4; \
++index )
{
if ( minyy > outpt [index] )
minyy = outpt [index];
if ( maxyy < outpt [index] )
maxyy = outpt [index];
}
minz = outpt [4];
maxz = outpt [4];
for ( index = 5; \
index < 8; \
++index )
{
if ( minz > outpt [index] )
minz = outpt [index];
if ( maxz < outpt [index] )
maxz = outpt [index];
}
}
else
{
minyy = in_bound [1];
maxyy = in_bound [4];
minz = in_bound [2];
maxz = in_bound [5];
}
if ( minyy < miny )
miny = minyy;
if ( maxyy > maxy )
maxy = maxyy;
out_bound [0] = minx + in_pos [0];
out_bound [1] = miny + in_pos [1];
out_bound [2] = minz + in_pos [2];
out_bound [3] = maxx + in_pos [0];
out_bound [4] = maxy + in_pos [1];
out_bound [5] = maxz + in_pos [2];
return;
}
void FX_CCharUtil::RemoveExtension ( char *in_source,
char *out_dest )
{
char *ch;
int pos;
ch = strrchr ( in_source, '.' );
pos = ch - in_source;
strncpy ( out_dest, in_source, pos );
out_dest [pos] = '\0';
return;
}
void FX_CCharUtil::TransformVertexForBBox ( const float *in_vec,
const float sinval,
const float cosval,
float *out_vec )
{
float a, b, c, d;
a = cosval * in_vec [0];
b = cosval * in_vec [1];
c = sinval * in_vec [2];
d = sinval * in_vec [3];
out_vec [0] = b - d;
out_vec [1] = a - d;
out_vec [2] = a - c;
out_vec [3] = b - c;
a = sinval * in_vec [0];
b = sinval * in_vec [1];
c = cosval * in_vec [2];
d = cosval * in_vec [3];
out_vec [4] = b + d;
out_vec [5] = a + d;
out_vec [6] = a + c;
out_vec [7] = b + c;
return;
}
int FX_CCharUtil::MakeAngleWithTime ( const float in_time,
const float in_vel )
{
return ( int (in_time * in_vel * (float)3600) % 3600 );
}
void BuildQuaternion ( const vec3_t in_base,
const vec3_t in_vector,
vec4_t out_quat )
{
double theta;
double s, c;
const float error = 0.0001f;
if ( (in_vector [0] + 1.0f) < error )
{
out_quat [0] = 0.0f;
out_quat [1] = 1.0f;
out_quat [2] = 0.0f;
out_quat [3] = 0.0f;
}
else if ( (1.0f - in_vector [0]) < error )
{
out_quat [0] = 0.0f;
out_quat [1] = 0.0f;
out_quat [2] = 0.0f;
out_quat [3] = 1.0f;
}
else
{
VectorCrossProduct ( g_nVector, in_base, in_vector );
D3DXVec3Normalize ( (D3DXVECTOR3 *)g_nVector, (D3DXVECTOR3 *)g_nVector );
theta = acos ( VectorDotProduct ( in_base, in_vector ) / VectorLength ( in_vector ) );
s = sin ( theta / 2 );
c = cos ( theta / 2 );
out_quat [0] = (float)(s * g_nVector [0]);
out_quat [1] = (float)(s * g_nVector [1]);
out_quat [2] = (float)(s * g_nVector [2]);
out_quat [3] = (float)c;
D3DXQuaternionNormalize ( (D3DXQUATERNION *)out_quat, (D3DXQUATERNION *)out_quat );
}
return;
}
void FX_CatmullRomMulti ( DIFFUSETEXVERTEX *out_pt,
const vec3_t in_first,
const vec3_t in_firstctrl,
const vec3_t in_second,
const vec3_t in_secondctrl,
int in_numpoints )
{
float disp = 1.0f / (float)( in_numpoints + 1 );
float weight = 0.0f, weightsquare, weighttriple;
VectorScale ( param1, in_first, 2.0f );
VectorSubtract ( param2, in_second, in_firstctrl );
param3 [0] = 2.0f * in_firstctrl [0] - 5.0f * in_first [0] + 4.0f * in_second [0] - in_secondctrl [0];
param3 [1] = 2.0f * in_firstctrl [1] - 5.0f * in_first [1] + 4.0f * in_second [1] - in_secondctrl [1];
param3 [2] = 2.0f * in_firstctrl [2] - 5.0f * in_first [2] + 4.0f * in_second [2] - in_secondctrl [2];
param4 [0] = -in_firstctrl [0] + 3.0f * in_first [0] - 3.0f * in_second [0] + in_secondctrl [0];
param4 [1] = -in_firstctrl [1] + 3.0f * in_first [1] - 3.0f * in_second [1] + in_secondctrl [1];
param4 [2] = -in_firstctrl [2] + 3.0f * in_first [2] - 3.0f * in_second [2] + in_secondctrl [2];
for ( int index = 0; \
index < in_numpoints; \
++index )
{
weight += disp;
weightsquare = weight * weight;
weighttriple = weightsquare * weight;
out_pt [2 * index].vecPos [0] = 0.5f * ( param1 [0] + param2 [0] * weight + param3 [0] * weightsquare + param4 [0] * weighttriple );
out_pt [2 * index].vecPos [1] = 0.5f * ( param1 [1] + param2 [1] * weight + param3 [1] * weightsquare + param4 [1] * weighttriple );
out_pt [2 * index].vecPos [2] = 0.5f * ( param1 [2] + param2 [2] * weight + param3 [2] * weightsquare + param4 [2] * weighttriple );
}
return;
}
void InverseRigidTransform ( matrix4x4_t *in_source,
matrix4x4_t *out_dest )
{
out_dest ->a00 = in_source ->a00;
out_dest ->a10 = in_source ->a01;
out_dest ->a20 = in_source ->a02;
out_dest ->a30 = 0.0f;
out_dest ->a01 = in_source ->a10;
out_dest ->a11 = in_source ->a11;
out_dest ->a21 = in_source ->a12;
out_dest ->a31 = 0.0f;
out_dest ->a02 = in_source ->a20;
out_dest ->a12 = in_source ->a21;
out_dest ->a22 = in_source ->a22;
out_dest ->a32 = 0.0f;
out_dest ->a03 = - ( in_source ->a03 * in_source ->a00 + in_source ->a13 * in_source ->a10 + in_source ->a23 * in_source ->a20 );
out_dest ->a13 = - ( in_source ->a03 * in_source ->a01 + in_source ->a13 * in_source ->a11 + in_source ->a23 * in_source ->a21 );
out_dest ->a23 = - ( in_source ->a03 * in_source ->a02 + in_source ->a13 * in_source ->a12 + in_source ->a23 * in_source ->a22 );
out_dest ->a33 = in_source ->a33;
}
void FastSlerp ( D3DXQUATERNION *out_quat,
D3DXQUATERNION *in_first,
D3DXQUATERNION *in_second,
const float in_disp )
{
if ( ( ( in_first->x - in_second->x ) < 0.001f ) &&
( ( in_first->y - in_second->y ) < 0.001f ) &&
( ( in_first->z - in_second->z ) < 0.001f ) &&
( ( in_first->w - in_second->w ) < 0.001f ) )
{
memcpy ( out_quat, in_first, sizeof(D3DXQUATERNION) );
return;
}
if ( ( ( in_first->x + in_second->x ) < 0.001f ) &&
( ( in_first->y + in_second->y ) < 0.001f ) &&
( ( in_first->z + in_second->z ) < 0.001f ) &&
( ( in_first->w + in_second->w ) < 0.001f ) )
{
memcpy ( out_quat, in_first, sizeof(D3DXQUATERNION) );
return;
}
D3DXQuaternionNormalize ( in_first, in_first );
D3DXQuaternionNormalize ( in_second, in_second );
double cosval = in_first ->x * in_second ->x + in_first ->y * in_second ->y + in_first ->z * in_second ->z + in_first ->w * in_second ->w;
double theta = acos ( cosval );
char temp [256];
if ( sin ( theta ) < 0.0001f )
{
sprintf ( temp, "ERROR!: sin value is too small!, cosval : %f", cosval );
ShowError ( temp, __FILE__, __LINE__ );
}
double invsin = 1.0f / sin ( theta );
double a = sin ( theta * ( 1.0f - in_disp ) ) * invsin;
double b = sin ( theta * in_disp ) * invsin;
out_quat ->x = a * in_first ->x + b * in_second ->x;
out_quat ->y = a * in_first ->y + b * in_second ->y;
out_quat ->z = a * in_first ->z + b * in_second ->z;
out_quat ->w = a * in_first ->w + b * in_second ->w;
D3DXQuaternionNormalize ( out_quat, out_quat );
}
| C++ |
#include "../../global_def.h"
#include "../Common.h"
CTagManager::CTagManager ()
{
m_numTagScript = 0;
}
CTagManager::~CTagManager ()
{
}
bool CTagManager::Load ( TCHAR* strFileName )
{
m_pScript->Load ( strFileName );
m_pScript->BeginParse ();
if ( RESOURCE_VERSION_VALUE > 100 )
{
char version [MAX_PATH];
strcpy ( version, m_pScript ->GetNextToken () );
if ( ! strncmp ( version, "VERSION", 7 ) )
{
if ( strncmp ( &version [7], RESOURCE_VERSION_TEXT, 3 ) )
{
}
}
else
{
}
}
m_iTagCount = atoi ( m_pScript->GetNextToken() );
m_aTagInfo = new stTAGINFO[m_iTagCount];
for ( int index = 0;
index < m_iTagCount;
++index
)
{
strcpy ( m_aTagInfo [index] .strName,
m_pScript->GetNextToken() );
strcpy ( m_aTagInfo [index] .szParentName,
m_pScript->GetNextToken() );
m_aTagInfo [index] .iIndex = atoi ( m_pScript->GetNextToken() );
}
char *pszTemp;
pszTemp = m_pScript->GetNextToken();
if ( stricmp ( pszTemp, "EOF" ) != 0 )
{
ShowError ( "Tag count doesn't match the actual data!", __FILE__, __LINE__ );
return false;
}
return true;
}
int CTagManager::GetIndex( char *pszMeshName )
{
for ( int index = 0;
index < m_iTagCount;
++index )
{
if ( _stricmp ( pszMeshName,
m_aTagInfo [index] .strName ) == 0
)
{
return m_aTagInfo [index] .iIndex;
}
}
ShowError ( _T ("Failed to find matching tag! Please check tag info file!"),
__FILE__,
__LINE__ );
return -1;
}
char* CTagManager::GetParentName ( const int iTagIndex )
{
if ( ( iTagIndex < 0 ) ||
( iTagIndex >= m_iTagCount )
)
{
char message [256];
sprintf ( message, "Tag index value is invalid!. Tag Index : %d\n", iTagIndex );
ShowError ( message,
__FILE__,
__LINE__ );
return NULL;
}
for ( int index = 0;
index < m_iTagCount;
++index )
{
if ( iTagIndex == m_aTagInfo [index] .iIndex )
return m_aTagInfo [index] .szParentName;
}
ShowError ( _T ("There's no matching tag! Please check tag info file!"),
__FILE__,
__LINE__ );
return NULL;
}
INT CTagManager::GetSize()
{
return m_iTagCount;
}
TCHAR* CTagManager::GetName ( const int iTagIndex )
{
if ( ( iTagIndex < 0 ) ||
( iTagIndex >= m_iTagCount )
)
{
char message [256];
sprintf ( message, "Tag index value is invalid!. Tag Index : %d\n", iTagIndex );
ShowError ( message,
__FILE__,
__LINE__ );
return NULL;
}
for ( int index = 0;
index < m_iTagCount;
++index )
{
if ( iTagIndex == m_aTagInfo [index] .iIndex )
return m_aTagInfo [index] .strName;
}
ShowError ( _T ("There's no matching tag! Please check tag info file!"),
__FILE__,
__LINE__ );
return NULL;
}
VOID CTagManager::Cleanup ()
{
GTH_SAFE_DELETE_ARRAY ( m_aTagInfo );
return;
}
int CTagManager::LoadTagScript ()
{
char *token;
FX_TAGSCRIPT_t *thisScript;
if ( ! m_pScript ->Load ( FILENAME_TAGSCRIPT_LIST ) )
return -1;
m_pScript->BeginParse ();
m_numTagScript = 0;
while ( 1 )
{
token = m_pScript ->GetNextToken ( true );
if ( ! token [0] ) break;
if ( token [0] != '{' ) continue;
if ( m_numTagScript >= FX_MAX_TAGSCRIPT )
{
ShowError ( "TAG SCRIPT OVERFLOW!", __FILE__, __LINE__ );
break;
}
thisScript = &m_tagScript [m_numTagScript++];
memset ( thisScript, 0, sizeof (FX_TAGSCRIPT_t) );
while ( 1 )
{
token = m_pScript ->GetNextToken ( true );
if ( ! token [0] ) break;
if ( token [0] == '}' ) break;
else
{
if ( ParseScriptToken ( thisScript, token ) == -1 )
return -1;
}
}
}
return true;
}
int CTagManager::ParseScriptToken ( FX_TAGSCRIPT_t *in_script,
char *in_token )
{
char *token;
int index;
int count;
if ( 0 == _stricmp ( in_token, TEXT ("name") ) )
{
strcpy ( in_script ->name, m_pScript ->GetNextToken ( true ) );
}
else if ( 0 == _stricmp ( in_token, TEXT ("model") ) )
{
in_script ->model = atoi ( m_pScript ->GetNextToken ( true ) );
}
else if ( 0 == _stricmp ( in_token, TEXT ("pos") ) )
{
in_script ->pos [0] = (float)atof ( m_pScript ->GetNextToken ( true ) );
in_script ->pos [1] = (float)atof ( m_pScript ->GetNextToken ( true ) );
in_script ->pos [2] = (float)atof ( m_pScript ->GetNextToken ( true ) );
}
else if ( 0 == _stricmp ( in_token, TEXT ("velocity") ) )
{
in_script ->velocity = (float)atof ( m_pScript ->GetNextToken ( true ) );
}
else if ( 0 == _stricmp ( in_token, TEXT ("x_func") ) )
{
FX_TS_FUNC *thisFunc = &in_script ->x_func;
token = ParseFuncScript ( thisFunc );
if ( token )
ParseScriptToken ( in_script, token );
}
else if ( 0 == _stricmp ( in_token, TEXT ("y_func") ) )
{
FX_TS_FUNC *thisFunc = &in_script ->y_func;
token = ParseFuncScript ( thisFunc );
if ( token )
ParseScriptToken ( in_script, token );
}
else if ( 0 == _stricmp ( in_token, TEXT ("z_func") ) )
{
FX_TS_FUNC *thisFunc = &in_script ->z_func;
token = ParseFuncScript ( thisFunc );
if ( token )
ParseScriptToken ( in_script, token );
}
else if ( 0 == _stricmp ( in_token, TEXT ("x_rotation") ) )
{
in_script ->x_rotation = (char)atoi ( m_pScript ->GetNextToken ( true ) );
in_script ->x_delay = (char)atoi ( m_pScript ->GetNextToken ( true ) );
}
else if ( 0 == _stricmp ( in_token, TEXT ("y_rotation") ) )
{
in_script ->y_rotation = (char)atoi ( m_pScript ->GetNextToken ( true ) );
in_script ->y_delay = (char)atoi ( m_pScript ->GetNextToken ( true ) );
}
else if ( 0 == _stricmp ( in_token, TEXT ("z_rotation") ) )
{
in_script ->z_rotation = (char)atoi ( m_pScript ->GetNextToken ( true ) );
in_script ->z_delay = (char)atoi ( m_pScript ->GetNextToken ( true ) );
}
else if ( 0 == _stricmp ( in_token, TEXT ("look") ) )
{
token = m_pScript ->GetNextToken ( true );
if ( 0 == _stricmp ( token, TEXT ("always_look_tgt") ) )
in_script ->look = ALWAYS_LOOK_TGT;
else if ( 0 == _stricmp ( token, TEXT ("always_look_fwd") ) )
in_script ->look = ALWAYS_LOOK_FWD;
else if ( 0 == _stricmp ( token, TEXT ("always_look_center") ) )
in_script ->look = ALWAYS_LOOK_CENTER;
else if ( 0 == _stricmp ( token, TEXT ("free_look") ) )
in_script ->look = FREE_LOOK;
}
else if ( 0 == _stricmp ( in_token, TEXT ("atk_effect") ) )
{
count = atoi ( m_pScript ->GetNextToken ( true ) );
if ( count > FX_TS_MAX_ATK_LVL )
{
ShowError ( "ATTACK EFFECT OVERFLOW!", __FILE__, __LINE__ );
return -1;
}
for ( index = 0; \
index < count; \
++index )
{
in_script ->effect_atk [index] = atoi ( m_pScript ->GetNextToken ( true ) );
}
}
else if ( 0 == _stricmp ( in_token, TEXT ("def_effect") ) )
{
count = atoi ( m_pScript ->GetNextToken ( true ) );
if ( count > FX_TS_MAX_DEF_LVL )
{
ShowError ( "DEFENSE EFFECT OVERFLOW!", __FILE__, __LINE__ );
return -1;
}
for ( index = 0; \
index < count; \
++index )
{
in_script ->effect_def [index] = atoi ( m_pScript ->GetNextToken ( true ) );
}
}
else if ( 0 == _stricmp ( in_token, TEXT ("mgk_effect") ) )
{
count = atoi ( m_pScript ->GetNextToken ( true ) );
if ( count > FX_TS_MAX_MGK_LVL )
{
ShowError ( "MAGIC EFFECT OVERFLOW!", __FILE__, __LINE__ );
return -1;
}
for ( index = 0; \
index < count; \
++index )
{
in_script ->effect_mgk [index] = atoi ( m_pScript ->GetNextToken ( true ) );
}
}
return true;
}
char* CTagManager::ParseFuncScript ( FX_TS_FUNC *in_func )
{
char *token;
token = m_pScript ->GetNextToken ( true );
if ( 0 == _stricmp ( token, TEXT ("sin_func") ) )
{
in_func ->func = SIN_FUNC;
token = ParseSubFuncScript ( in_func, false );
if ( token )
return token;
}
else if ( 0 == _stricmp ( token, TEXT ("minus_sin_func") ) )
{
in_func ->func = SIN_FUNC;
token = ParseSubFuncScript ( in_func, true );
if ( token )
return token;
}
else if ( 0 == _stricmp ( token, TEXT ("cos_func") ) )
{
in_func ->func = COS_FUNC;
token = ParseSubFuncScript ( in_func, false );
if ( token )
return token;
}
else if ( 0 == _stricmp ( token, TEXT ("minus_cos_func") ) )
{
in_func ->func = COS_FUNC;
token = ParseSubFuncScript ( in_func, true );
if ( token )
return token;
}
else if ( 0 == _stricmp ( token, TEXT ("fixed") ) )
{
in_func ->func = POS_FIXED;
}
return NULL;
}
char* CTagManager::ParseSubFuncScript ( FX_TS_FUNC *in_func,
const bool in_isMinus )
{
char *token;
in_func ->scale = atoi ( m_pScript ->GetNextToken ( true ) );
if ( in_isMinus )
in_func ->scale = -in_func ->scale;
token = m_pScript ->GetNextToken ( true );
if ( 0 == _stricmp ( token, TEXT ("angle_mul") ) )
{
in_func ->angle_mul = (float)atof ( m_pScript ->GetNextToken ( true ) );
}
else
{
in_func ->angle_mul = 1.0f;
return token;
}
return NULL;
}
int CTagManager::ScriptSearch ( char *in_name )
{
for ( int index = 0; \
index < m_numTagScript; \
++index )
{
if ( stricmp ( m_tagScript [index].name, in_name ) == 0 )
return index;
}
ShowError ( TEXT ("THERE'S NO MATCHING SCRIPT!"), __FILE__, __LINE__ );
return -1;
}
float CTagManager::GetDisplacement ( const FX_TS_FUNCTYPE in_functype,
const int in_angle )
{
switch ( in_functype )
{
case POS_FIXED:
return 0.0f;
case SIN_FUNC:
return m_pMathTbl ->m_sin [in_angle];
case COS_FUNC:
return m_pMathTbl ->m_cos [in_angle];
}
return NULL;
}
| C++ |
#ifndef _SKINNING_MESH_MANAGER_H_J0J092JD0293
#define _SKINNING_MESH_MANAGER_H_J0J092JD0293
typedef struct
{
FX_CMesh mesh;
int iRefID;
int itemID;
int partID;
} SKIN_t;
#define MAX_DEF_SKIN 10
typedef struct
{
int list [MAX_COUNT_SKIN_PART][MAX_DEF_SKIN];
int count [MAX_COUNT_SKIN_PART];
} FX_DEF_SKIN_t;
class FX_CSkinManager
{
public:
FX_CSkinManager();
~FX_CSkinManager() {};
public:
SKIN_t m_Skins [MAX_COUNT_SKIN_MESH];
int m_iNumSkins;
CHAR_BUFFER_t m_CharBuffer [MAX_COUNT_AVAIL_ITEM];
int m_iNumMeshInBuffer;
int m_iBufferIndexMap [MAX_COUNT_SKIN_MESH];
Fx_SKIN_BUF_t m_SkinBuffer [MAX_COUNT_SKIN_MESH];
int m_meshOffset [MAX_COUNT_SKIN_PART];
LPDIRECT3DDEVICE8 m_pd3dDevice;
FX_CSkinRenderer *m_pSkinRenderer;
FX_CCharManager *m_pCharManager;
FX_CCharUtil *m_pCharUtil;
FX_CSkelManager *m_pSkelManager;
FX_CCharShaderMng *m_pCharShaderMng;
CScript *m_pScript;
CD3DTextureMng *m_texMng;
CFileMng *m_fileMng;
CD3DRender *m_D3DRender;
CShaderMng *m_shaderMng;
FX_DEF_SKIN_t m_defSkinList [NUM_GEN_TYPE];
public:
bool LoadSkinList();
void UpdateTextureID();
bool PrepareRenderBuffers();
bool ReleaseRenderBuffers();
bool RenderAllNormal ( int *in_numprims );
#ifdef _FX_CLIENT
bool RenderAllDisappear ( int *in_numprims );
#endif
bool UpdateCharBuffer();
void Cleanup();
void SetCharManager ( FX_CCharManager *charManager ) { m_pCharManager = charManager; }
void SetCharUtil ( FX_CCharUtil *charUtil ) { m_pCharUtil = charUtil; }
void SetSkelManager ( FX_CSkelManager *skelManager );
void SetScript ( CScript *script ) { m_pScript = script; }
void SetDevice ( LPDIRECT3DDEVICE8 device );
void SetTexManager ( CD3DTextureMng *texMng );
void SetFileManager ( CFileMng *fileMng ) { m_fileMng = fileMng; }
void SetRenderer ( CD3DRender *d3dRender );
void SetShaderMng ( CShaderMng *shaderMng );
void SetCharShaderMng ( FX_CCharShaderMng *charShaderMng ) { m_pCharShaderMng = charShaderMng; };
int MakeSkinID ( const int in_type, const int in_internalID );
void SplitSkinID ( const int in_skinID, int &out_type, int &out_internalID );
int LoadDefSkinList ();
int ParseSubDefSkinList ( char *in_token );
int ParseNextLevel ( int *out_list, int &out_count );
void GetDefaultSkin ( const int in_gentype, const int in_type, int *out_list, int &out_count );
int GetDefaultSkinID ( const int in_gentype, const int in_type, const int idx );
int GetNumVertex ( const int in_skinID, const int in_LODLevel );
int GetNumIndex ( const int in_skinID, const int in_LODLevel );
void SetSkinRenderer ( FX_CSkinRenderer *skinRenderer ) { m_pSkinRenderer = skinRenderer; };
void SetTextureByRef ( int in_ref );
void DiscardAllIndexBuffers ();
void DiscardIndexBuffer ( Fx_CHARACTER_t *in_char );
void DiscardAllVertexBuffers ();
void DiscardVertexBuffer ( Fx_CHARACTER_t *in_char );
private:
bool LoadSkin ( char *pszSkinName, const unsigned int &iSkinID, const unsigned int &iTexID );
bool SetRenderState ();
};
#endif | C++ |
#include "../../global_def.h"
#include "../Common.h"
#include "Mmsystem.h"
#define g_mat GLOBAL_DXMATRIX_1
#define g_disp GLOBAL_DXVEC3_1
#define g_selfRot GLOBAL_QUAT_1
#define g_vecAfterTransform GLOBAL_DXVEC3_1
#define g_quatAfterTransform GLOBAL_QUAT_1
#define g_quatTarget GLOBAL_QUAT_2
#define g_quatConjugate GLOBAL_QUAT_3
#define g_tgtPos GLOBAL_DXVEC3_1
#define g_direction GLOBAL_DXVEC3_2
#define g_scalevector GLOBAL_DXVEC3_3
#define g_resultMatrix GLOBAL_MATRIX_1
#define g_buffer GLOBAL_VEC4_4
vec3_t g_baseVector = { 0.0f, -1.0f, 0.0f };
FX_CItemManager::FX_CItemManager ()
{
m_pItemRenderer = new FX_CItemRenderer();
m_pItemRenderer->SetItemManager ( this );
m_iNumItems = 0;
if ( g_resCounter->Enabled() )
{
g_resCounter->Add_DataType( RESCOUNTER_CHAR_ITEMMANAGER, sizeof(FX_CItemManager) );
}
}
FX_CItemManager::~FX_CItemManager ()
{
}
bool FX_CItemManager::LoadItemList ()
{
int index;
UINT iRefID;
int errorval;
errorval = m_pScript->Load ( FILENAME_ITEM_LIST );
if ( ! errorval ) return false;
m_pScript->BeginParse ();
m_iNumItems = atoi ( m_pScript->GetNextToken() );
for ( index = 0; \
index < m_iNumItems; \
++index )
{
strcpy ( m_ItemBuffer [index].name,
m_pScript->GetNextToken() );
m_ItemBuffer [index].id = index;
sprintf ( m_ItemBuffer [index].texname,
"%s",
m_pScript->GetNextToken() );
iRefID = m_pCharShaderMng ->SearchShaderRef ( m_ItemBuffer [index].texname );
LoadItem ( m_ItemBuffer [index].name,
m_ItemBuffer [index].id,
iRefID );
}
return true;
}
void FX_CItemManager::UpdateTextureID ()
{
for ( int index = 0;
index < m_iNumItems;
++index )
{
m_Items [ m_ItemBuffer [index].id ].iRefID
= m_pCharShaderMng ->SearchShaderRef ( m_ItemBuffer [index].texname );
}
}
bool FX_CItemManager::LoadItem ( char *pszItemName,
const UINT iItemID,
const UINT iRefID )
{
ITEM_t* pItem;
char strTemp [MAX_PATH];
pItem = &m_Items [iItemID];
pItem->mesh.LoadData ( pszItemName,
m_fileMng );
pItem->iRefID = iRefID;
strcpy ( strTemp,
pItem->mesh.m_strMeshName );
char *chTemp = strrchr ( strTemp,
'+'
);
if ( chTemp )
{
int pos;
pos = chTemp - strTemp;
strcpy ( strTemp + pos,
"\0"
);
}
if ( strncmp ( strTemp, _T ("tag_"), 4 ) == 0 )
{
pItem->iTagIndex = m_pTagManager->GetIndex ( strTemp );
if ( pItem->iTagIndex == -1 )
return false;
char szTemp [256];
strcpy ( szTemp,
m_pTagManager->GetParentName ( pItem->iTagIndex )
);
pItem->iParentTagIndex = m_pBoneManager->GetIndex ( szTemp );
if ( pItem->iParentTagIndex == -1 )
return false;
}
return true;
}
bool FX_CItemManager::CountVertices ( UINT &iVertexResult,
UINT &iIndexResult )
{
iVertexResult = 0;
iIndexResult = 0;
UINT iIndexTemp = 0;
UINT iVertexTemp = 0;
MESHCHUNK* pMesh;
for ( int index = 0;
index < m_iNumItems;
++index )
{
pMesh = m_Items [index].mesh.m_meshes [0].meshchunk;
m_Items [index].iVertexStart = iVertexTemp;
m_Items [index].iIndexStart = iIndexTemp;
m_Items [index] .iNumVertex = pMesh->iNumVertexMap;
iVertexResult += pMesh->iNumVertexMap;
m_Items [index] .iPrimitiveCount = pMesh->iNumFace;
iIndexResult += pMesh->iNumFace * 3;
iVertexTemp = iVertexResult;
iIndexTemp = iIndexResult;
}
return true;
}
void FX_CItemManager::PrepareRenderBuffers ()
{
if ( m_iNumItems > 0 )
{
m_pItemRenderer ->CreateBuffers ();
m_pItemRenderer ->FillBuffers ();
}
return;
}
void FX_CItemManager::ReleaseRenderBuffers ()
{
if ( m_iNumItems > 0 )
m_pItemRenderer ->ReleaseBuffers ();
return;
}
void FX_CItemManager::SetRenderer ( CD3DRender *d3dRender )
{
m_D3DRender = d3dRender;
m_pItemRenderer ->SetRenderer ( d3dRender );
return;
}
void FX_CItemManager::SetShaderMng ( CShaderMng *shaderMng )
{
m_shaderMng = shaderMng;
return;
}
bool FX_CItemManager::RenderAll ( int *out_numprims )
{
ITEM_t *pThisItem;
CHAR_BUFFER_t *pCharBuffer;
Fx_CHARACTER_t *pCharacter;
int iRefIndex;
int result;
matrix4x4_t *mat_trans;
extern Fx_CHARACTER_t *g_mouseSelectedCharacter;
#ifdef _FX_CLIENT
Fx_CHARACTER_t *pTargetChar = NULL;
if ( g_cgv.state == CLIENT_GAME_PROCESS )
{
if ( g_mouseSelectedCharacter != NULL && g_cgv.pTargetChar != NULL )
pTargetChar = g_cgv.pTargetChar;
if ( g_mouseSelectedCharacter != NULL && g_cgv.pTargetChar == NULL )
pTargetChar = g_mouseSelectedCharacter;
if ( g_mouseSelectedCharacter == NULL && g_cgv.pTargetChar != NULL )
pTargetChar = g_cgv.pTargetChar;
if ( g_mouseSelectedCharacter == NULL && g_cgv.pTargetChar == NULL )
pTargetChar = NULL;
}
else
pTargetChar = g_mouseSelectedCharacter;
#endif
if ( m_iNumItems <= 0 )
return true;
result = m_pItemRenderer ->PrepareRender ();
for ( int index = 0;
index < m_iNumMeshInBuffer;
++index )
{
pCharBuffer = &m_CharBuffer [index];
pThisItem = &m_Items[ pCharBuffer->meshID ];
iRefIndex = pThisItem->iRefID;
if ( iRefIndex < 0 )
{
ErrorLog( "index : %d, mesh idx : %d, RefID of ITEM has some problem!", index, pCharBuffer->meshID );
continue;
}
if ( m_pCharShaderMng ->CheckIsShader ( iRefIndex ) )
{
m_pCharShaderMng ->PrepareShaderByRef ( iRefIndex );
}
else
{
m_D3DRender ->SetTexture ( 0, m_pCharShaderMng ->GetD3DTextureByRef ( iRefIndex ) );
}
for ( int subindex = 0; \
subindex < pCharBuffer->count; \
++subindex )
{
pCharacter = pCharBuffer->characterPtr[ subindex ];
if ( ! pCharacter->ren_renderThisFrame )
continue;
mat_trans = GetTagMatrix ( pCharacter, pCharBuffer ->tagID [subindex], pCharBuffer ->parentTagID [subindex] );
if ( ! mat_trans )
continue;
m_D3DRender ->SetTransform ( D3DTS_WORLD, mat_trans );
if ( ( pThisItem ->iVertexStart < 0 ) ||
( pThisItem ->iNumVertex < 0 ) ||
( pThisItem ->iIndexStart < 0 ) ||
( pThisItem ->iPrimitiveCount < 0 ) )
{
ErrorLog( "vertex start pos : %d, num vertex : %d, index start pos : %d, prim count : %d", pThisItem->iVertexStart, pThisItem->iNumVertex, pThisItem->iIndexStart, pThisItem->iPrimitiveCount );
continue;
}
#ifdef _FX_CLIENT
if ( ( pTargetChar != pCharacter ) ||
( g_cgv.state == CLIENT_GAME_PROCESS && pCharacter->ID == 0 ) )
#else
if ( true )
#endif
{
Render ( pCharacter, iRefIndex, pThisItem );
*out_numprims += pThisItem ->iPrimitiveCount;
}
else
{
Render ( pCharacter, iRefIndex, pThisItem );
}
}
}
return true;
}
void FX_CItemManager::Render ( Fx_CHARACTER_t *in_char,
const int in_refIdx,
const ITEM_t *pThisItem )
{
if ( m_pCharShaderMng ->CheckIsShader ( in_refIdx ) )
{
shader_t *thisShader = m_pCharShaderMng ->GetShaderByRef ( in_refIdx );
#ifdef _FX_CLIENT
if ( thisShader ->flags & SHADER_TCGEN )
m_shaderMng ->PrepareTCGen ( thisShader, in_char ->position );
#endif
m_D3DRender ->RenderMDLCustom ( thisShader,
pThisItem ->iVertexStart,
pThisItem ->iNumVertex,
pThisItem ->iIndexStart,
pThisItem ->iPrimitiveCount * 3 );
}
else
{
m_D3DRender ->RenderDefault ( pThisItem ->iVertexStart,
pThisItem ->iNumVertex,
pThisItem ->iIndexStart,
pThisItem ->iPrimitiveCount * 3 );
}
return;
}
void FX_CItemManager::EffectRender ( Fx_CHARACTER_t *in_char,
const int in_refIdx,
const ITEM_t *pThisItem )
{
if ( m_pCharShaderMng ->CheckIsEffectShader ( in_refIdx ) )
{
shader_t *thisShader = m_pCharShaderMng ->GetShaderByRef ( in_refIdx );
#ifdef _FX_CLIENT
if ( thisShader ->flags & SHADER_TCGEN )
m_shaderMng ->PrepareTCGen ( thisShader, in_char ->position );
#endif
m_D3DRender ->RenderMDLCustom ( m_pCharShaderMng ->GetEffectShaderByRef ( in_refIdx ),
pThisItem ->iVertexStart,
pThisItem ->iNumVertex,
pThisItem ->iIndexStart,
pThisItem ->iPrimitiveCount * 3 );
}
else
{
m_D3DRender ->RenderDefault ( pThisItem ->iVertexStart,
pThisItem ->iNumVertex,
pThisItem ->iIndexStart,
pThisItem ->iPrimitiveCount * 3 );
}
return;
}
void FX_CItemManager::SetTexManager ( CD3DTextureMng *texMng )
{
m_texMng = texMng;
return;
}
void FX_CItemManager::SetDevice( LPDIRECT3DDEVICE8 device )
{
m_pd3dDevice = device;
m_pItemRenderer->SetDevice ( m_pd3dDevice );
return;
}
bool FX_CItemManager::UpdateCharBuffer ()
{
if ( m_iNumItems <= 0 ) return true;
for ( int index = 0;
index < MAX_COUNT_ITEM_MESH;
++index )
{
m_iBufferIndexMap [index] = -1;
}
m_iNumMeshInBuffer = 0;
Fx_CHARACTER_t *pCharacter;
int iItemID;
CHAR_BUFFER_t *pCharBuffer;
for ( index = 0;
index < m_pCharManager->m_iNumCharacters;
++index )
{
pCharacter = &m_pCharManager->m_Characters [index];
for ( int subindex = 0;
subindex < MAX_COUNT_ITEM_PART;
++subindex )
{
iItemID = pCharacter ->stat_itemID [subindex];
if ( iItemID == -1 )
continue;
if ( m_iBufferIndexMap [iItemID] == -1 )
{
m_iBufferIndexMap [iItemID] = m_iNumMeshInBuffer;
pCharBuffer = &m_CharBuffer [m_iNumMeshInBuffer];
pCharBuffer->meshID = iItemID;
pCharBuffer->count = 1;
pCharBuffer->characterPtr [0] = pCharacter;
pCharBuffer->tagID [0] = subindex;
pCharBuffer->parentTagID [0] = m_pBoneManager ->GetIndex ( m_pTagManager ->GetParentName ( subindex ) );
++m_iNumMeshInBuffer;
}
else
{
pCharBuffer = &m_CharBuffer [m_iBufferIndexMap [iItemID]];
++(pCharBuffer->count);
pCharBuffer->characterPtr[ pCharBuffer->count - 1 ] = pCharacter;
pCharBuffer->tagID[ pCharBuffer->count - 1 ] = subindex;
pCharBuffer->parentTagID[ pCharBuffer->count - 1 ] = m_pBoneManager->GetIndex( m_pTagManager->GetParentName( subindex ) );
}
}
}
return true;
}
void FX_CItemManager::Cleanup ()
{
for ( int index = 0;
index < m_iNumItems;
++index )
{
m_Items [index] .mesh .Cleanup();
}
m_pItemRenderer->Cleanup();
GTH_SAFE_DELETE ( m_pItemRenderer );
return;
}
matrix4x4_t* FX_CItemManager::GetTagMatrixOut ( Fx_CHARACTER_t *in_char,
const int in_tag )
{
return GetTagMatrix( in_char, in_tag, m_pBoneManager->GetIndex( m_pTagManager->GetParentName( in_tag ) ) );
}
matrix4x4_t* FX_CItemManager::GetTagMatrix ( Fx_CHARACTER_t *in_char,
const int in_tag,
const int in_parentTag )
{
if ( m_pSkelManager ->m_iBoneLookUp [in_char ->attr_skelID][in_parentTag] < 0 )
{
ErrorLog( "skel index : %d, parent tag : %d, bone index : %d", in_char->attr_skelID, in_parentTag, m_pSkelManager ->m_iBoneLookUp [in_char ->attr_skelID][in_parentTag] );
return NULL;
}
if ( in_char ->flag_tagMatrixMade [in_tag] == false )
{
KEYFRAME *thisFrame = &in_char ->key_resultFrames [m_pSkelManager ->m_iBoneLookUp [in_char ->attr_skelID][in_parentTag]];
TAG *thisTag = &m_pSkelManager ->m_Skels [in_char ->attr_skelID].skeleton.m_Tag [in_tag];
MakeTagMatrix( in_char, thisFrame, thisTag, in_tag, in_char->ren_tagMatrixData[ in_tag ], true );
in_char ->flag_tagMatrixMade [in_tag] = true;
}
return &in_char ->ren_tagMatrixData [in_tag];
}
void FX_CItemManager::MakeTagMatrix ( const Fx_CHARACTER_t *in_char,
const KEYFRAME *in_frame,
const TAG *in_tag,
const int in_tagID,
matrix4x4_t &out_matrix,
const bool in_transform )
{
int overallTime;
FX_TAGSCRIPT_t *script;
int angle;
float *quat;
float preval;
float yaw = 0.0f, pitch = 0.0f, roll = 0.0f;
switch ( in_tagID )
{
case ITEM_PART_OVERHEAD_FAR:
case ITEM_PART_OVERHEAD_NEAR:
case ITEM_PART_MIDDLEAIR_R:
case ITEM_PART_MIDDLEAIR_L:
script = m_pTagManager ->GetScript (in_char ->stat_moveID [in_tagID]);
if ( script ->x_func.func != POS_FIXED )
{
angle = m_pCharUtil ->MakeAngleWithTime ( m_timer ->GetAppTime () * script ->x_func.angle_mul,
script ->velocity );
g_disp [0] = script ->x_func.scale * m_pTagManager ->GetDisplacement ( script ->x_func.func, angle );
}
else
g_disp [0] = 0.0f;
if ( script ->y_func.func != POS_FIXED )
{
angle = m_pCharUtil ->MakeAngleWithTime ( m_timer ->GetAppTime () * script ->y_func.angle_mul,
script ->velocity );
g_disp [1] = script ->y_func.scale * m_pTagManager ->GetDisplacement ( script ->y_func.func, angle );
}
else
g_disp [1] = 0.0f;
if ( script ->z_func.func != POS_FIXED )
{
angle = m_pCharUtil ->MakeAngleWithTime ( m_timer ->GetAppTime () * script ->z_func.angle_mul,
script ->velocity );
g_disp [2] = script ->z_func.scale * m_pTagManager ->GetDisplacement ( script ->z_func.func, angle );
}
else
g_disp [2] = 0.0f;
g_vecAfterTransform [0] = ( script ->pos [0] + in_frame ->vecOffset [0] + g_disp [0] ) * in_char->stat_scale;
g_vecAfterTransform [1] = ( script ->pos [1] + in_frame ->vecOffset [1] + g_disp [1] ) * in_char->stat_scale;
g_vecAfterTransform [2] = ( script ->pos [2] + in_frame ->vecOffset [2] + g_disp [2] ) * in_char->stat_scale;
switch ( script ->look )
{
case ALWAYS_LOOK_TGT:
TagLookTarget ( g_vecAfterTransform, in_char ->targetIdx, g_quatAfterTransform );
quat = g_quatAfterTransform;
break;
case ALWAYS_LOOK_FWD:
quat = NULL;
break;
case ALWAYS_LOOK_CENTER:
VectorNegate ( g_disp, g_disp );
TagLookCenter ( g_disp, g_quatAfterTransform );
quat = g_quatAfterTransform;
break;
case FREE_LOOK:
int timeFactor = int (m_timer ->GetAppTime () * 0.5f) % 3;
quat = g_quatAfterTransform;
switch ( timeFactor )
{
case 0:
TagLookTarget ( g_vecAfterTransform, in_char ->targetIdx, g_quatAfterTransform );
break;
case 1:
quat = NULL;
break;
case 2:
VectorNegate ( g_disp, g_disp );
TagLookCenter ( g_disp, g_quatAfterTransform );
break;
}
}
preval = __TWOPI * m_timer ->GetAppTime ();
if ( script ->x_rotation > 0 )
{
overallTime = script ->x_rotation + script ->x_delay;
if ( (int (m_timer ->GetAppTime ()) % overallTime) < script ->x_rotation )
{
pitch = script ->x_rotation * preval;
}
else
{
pitch = 0.0f;
}
}
if ( script ->y_rotation > 0 )
{
overallTime = script ->y_rotation + script ->y_delay;
if ( (int (m_timer ->GetAppTime ()) % overallTime) < script ->y_rotation )
{
yaw = script ->y_rotation * preval;
}
else
{
yaw = 0.0f;
}
}
if ( script ->z_rotation > 0 )
{
overallTime = script ->z_rotation + script ->z_delay;
if ( (int (m_timer ->GetAppTime ()) % overallTime) < script ->z_rotation )
{
roll = script ->z_rotation * preval;
}
else
{
roll = 0.0f;
}
}
if ( (script ->x_rotation + script ->y_rotation + script ->z_rotation) > 0 )
{
D3DXQuaternionRotationYawPitchRoll ( (D3DXQUATERNION *)g_selfRot, yaw, pitch, roll );
if ( quat )
{
D3DXQuaternionMultiply ( (D3DXQUATERNION *)quat, (D3DXQUATERNION *)g_selfRot, (D3DXQUATERNION *)quat );
D3DXMatrixTransformation ( (D3DXMATRIX *)&g_mat, NULL, NULL, NULL, NULL, (D3DXQUATERNION *)quat, (D3DXVECTOR3 *)g_vecAfterTransform );
}
else
D3DXMatrixTransformation ( (D3DXMATRIX *)&g_mat, NULL, NULL, NULL, NULL, (D3DXQUATERNION *)g_selfRot, (D3DXVECTOR3 *)g_vecAfterTransform );
}
else
{
D3DXMatrixTransformation ( (D3DXMATRIX *)&g_mat, NULL, NULL, NULL, NULL, (D3DXQUATERNION *)quat, (D3DXVECTOR3 *)g_vecAfterTransform );
}
if ( in_transform )
D3DXMatrixMultiply ( (D3DXMATRIX *)&out_matrix, (D3DXMATRIX *)&g_mat, (D3DXMATRIX *)&in_char ->stat_matTransform );
else
memcpy( &out_matrix, &g_mat, sizeof(matrix4x4_t) );
break;
case ITEM_PART_ARM_R:
case ITEM_PART_ARM_L:
case ITEM_PART_NECK:
case ITEM_PART_BODY:
case ITEM_PART_HAND_R:
case ITEM_PART_HAND_L:
case ITEM_PART_BACKHAND_R:
case ITEM_PART_BACKHAND_L:
case ITEM_PART_KNEE_R:
case ITEM_PART_KNEE_L:
case ITEM_PART_WAIST:
case ITEM_PART_SHOULDER:
case ITEM_PART_BACK:
case ITEM_PART_WAIST_R:
case ITEM_PART_WAIST_L:
case ITEM_PART_ELBOW_R:
case ITEM_PART_ELBOW_L:
case ITEM_PART_HAIR:
case ITEM_PART_HEAD:
case ITEM_PART_FACE:
case ITEM_PART_TRANS:
case ITEM_PART_GROUNDAIR_R:
case ITEM_PART_GROUNDAIR_L:
case ITEM_PART_CREATURE_TYPE_0:
case ITEM_PART_CREATURE_TYPE_1:
case ITEM_PART_CREATURE_TYPE_2:
case ITEM_PART_CREATURE_TYPE_3:
case ITEM_PART_CREATURE_TYPE_4:
g_quatTarget [0] = in_tag ->position [0];
g_quatTarget [1] = in_tag ->position [1];
g_quatTarget [2] = in_tag ->position [2];
g_quatTarget [3] = 0.0f;
D3DXQuaternionConjugate ( (D3DXQUATERNION *)g_quatConjugate, (D3DXQUATERNION *)in_frame ->quatCoordinate );
Fx_Quat3Multiply( g_quatAfterTransform, g_buffer, in_frame ->quatCoordinate, g_quatTarget, g_quatConjugate );
g_vecAfterTransform [0] = g_quatAfterTransform [0] +
in_frame ->vecOffset [0];
g_vecAfterTransform [1] = g_quatAfterTransform [1] +
in_frame ->vecOffset [1];
g_vecAfterTransform [2] = g_quatAfterTransform [2] +
in_frame ->vecOffset [2];
D3DXQuaternionMultiply ( (D3DXQUATERNION *)g_quatAfterTransform, (D3DXQUATERNION *)in_frame ->quatCoordinate, (D3DXQUATERNION *)in_tag ->rotation );
D3DXQuaternionInverse ( (D3DXQUATERNION *)g_quatAfterTransform, (D3DXQUATERNION *)g_quatAfterTransform );
D3DXMatrixTransformation ( (D3DXMATRIX *)&g_mat, NULL, NULL, NULL, NULL, (D3DXQUATERNION *)g_quatAfterTransform, (D3DXVECTOR3 *)g_vecAfterTransform );
if ( in_transform )
D3DXMatrixMultiply ( (D3DXMATRIX *)&out_matrix, (D3DXMATRIX *)&g_mat, (D3DXMATRIX *)&in_char ->stat_matTransform );
else
memcpy( &out_matrix, &g_mat, sizeof(matrix4x4_t) );
break;
case ITEM_PART_GROUND:
g_vecAfterTransform [0] = in_char ->position [0];
g_vecAfterTransform [1] = in_char ->position [1];
g_vecAfterTransform [2] = 5.0f;
D3DXQuaternionRotationYawPitchRoll ( (D3DXQUATERNION *)g_quatAfterTransform, deg2rad ( in_char ->angles [YAW] ) + __HALFPI, 0.0f, 0.0f );
D3DXQuaternionInverse ( (D3DXQUATERNION *)g_quatAfterTransform, (D3DXQUATERNION *)g_quatAfterTransform );
D3DXMatrixTransformation ( (D3DXMATRIX *)&out_matrix, NULL, NULL, NULL, NULL,
(D3DXQUATERNION *)g_quatAfterTransform, (D3DXVECTOR3 *)g_vecAfterTransform );
break;
}
}
void FX_CItemManager::TagLookTarget ( const vec3_t in_mypos,
const int in_tgtIdx,
vec4_t out_quat )
{
g_direction [0] = 1.0f;
g_direction [1] = 1.0f;
g_direction [2] = 1.0f;
BuildQuaternion ( g_baseVector, g_direction, out_quat );
return;
}
void FX_CItemManager::TagLookCenter ( const vec3_t in_direction,
vec4_t out_quat )
{
BuildQuaternion ( g_baseVector, in_direction, out_quat );
return;
}
void FX_CItemManager::GetTagMatrixUntransformed ( Fx_CHARACTER_t *in_char,
const int in_tag,
const int in_parentTag,
matrix4x4_t &out_matrix )
{
KEYFRAME *thisFrame = &in_char ->key_resultFrames [m_pSkelManager ->m_iBoneLookUp [in_char ->attr_skelID][in_parentTag]];
TAG *thisTag = &m_pSkelManager ->m_Skels [in_char ->attr_skelID].skeleton.m_Tag [in_tag];
MakeTagMatrix ( in_char, thisFrame, thisTag, in_tag, out_matrix, false );
}
#ifdef _FX_CLIENT
void FX_CItemManager::GetCharPosByIdxOnSvr ( const int in_targetIdx,
vec3_t out_pos )
{
Fx_CHARACTER_t *thisChar;
for ( int index = 0; \
index < m_pCharManager ->m_iNumCharacters; \
++index )
{
if ( m_pCharManager ->m_Characters [index].idxOnServer == in_targetIdx )
{
thisChar = &m_pCharManager ->m_Characters [index];
break;
}
}
out_pos [0] = thisChar ->position [0];
out_pos [1] = thisChar ->position [1];
out_pos [2] = thisChar ->position [2];
return;
}
#endif | C++ |
#include "../../global_def.h"
#include "../Common.h"
#define CHAR_LOOKUP_VERSION_TEXT "101"
#define CHAR_LOOKUP_VERSION_VALUE 101
void FX_CCharLookupMng::LoadTableInfo ()
{
BYTE *pFileBuffer;
int offset = 0;
pFileBuffer = m_fileMng ->ReadFileFromPack ( FILENAME_CHARTABLE );
for ( int index = 0; \
index < NUM_GEN_LOOKUPS; \
++index )
{
GetDataFromBuffer ( (void *)&m_charLookups [index], pFileBuffer, sizeof (Fx_CHAR_LOOKUP_t), offset );
}
GTH_SAFE_FREE ( pFileBuffer );
return;
}
void FX_CCharLookupMng::InitTableInfo ()
{
int i, j, k;
for ( i = 0; \
i < NUM_GEN_LOOKUPS; \
++i )
{
for ( j = 0; \
j < MAX_ANIMCOUNT_ITEM; \
++j )
{
for ( k = 0; \
k < MAX_ANIMCOUNT_TYPE; \
++k )
{
m_charLookups [i].animset.anim_item [j].anim_type [k] = -1;
#ifdef _GTH_NEW_VERSION
m_creatureLookups [i].animset.anim_item [j].anim_type [k] = -1;
#endif
}
m_charLookups [i].animset.anim_item [j].desc [0] = NULL;
#ifdef _GTH_NEW_VERSION
m_creatureLookups [i].animset.anim_item [j].desc [0] = NULL;
#endif
}
for ( j = 0; \
j < MAX_ANIMCOUNT_COMMON; \
++j )
{
m_charLookups [i].animset.anim_common [j] = -1;
#ifdef _GTH_NEW_VERSION
m_creatureLookups [i].animset.anim_common [j] = -1;
#endif
}
m_charLookups [i].animset.commonDesc [0] = NULL;
#ifdef _GTH_NEW_VERSION
m_creatureLookups [i].animset.commonDesc [0] = NULL;
#endif
for ( j = 0; \
j < MAX_ANIMCOUNT_SKILL; \
++j )
{
m_charLookups [i].animset.anim_skill [j] = -1;
#ifdef _GTH_NEW_VERSION
m_creatureLookups [i].animset.anim_skill [j] = -1;
#endif
}
m_charLookups [i].animset.skillDesc [0] = NULL;
#ifdef _GTH_NEW_VERSION
m_creatureLookups [i].animset.skillDesc [0] = NULL;
#endif
m_charLookups [i].boneIdx = -1;
}
for ( i = 0; \
i < NUM_MON_LOOKUPS; \
++i )
{
for ( j = 0; \
j < MAX_ANIMCOUNT_TYPE; \
++j )
{
m_monLookups [i].anim_monster [j] = -1;
}
m_monLookups [i].desc [0] = NULL;
m_monLookups [i].boneIdx = -1;
}
for ( i = 0; \
i < MAX_COUNT_ANIM; \
++i )
{
memset ( &m_aniInfo [i], 0, sizeof (Fx_ANIM_INFO_t) );
}
}
void FX_CCharLookupMng::SaveTableInfoFromFile ( char *filename )
{
int i;
FILE *fp;
fp = fopen ( filename, "wb" );
#ifdef _GTH_NEW_VERSION
char version [MAX_PATH];
sprintf ( version, "VERSION%3d", CHAR_LOOKUP_VERSION_VALUE );
fwrite ( version, strlen(version), 1, fp );
#endif
for( i = 0; i < NUM_GEN_LOOKUPS; i ++ )
{
fwrite( & m_charLookups[i], sizeof( Fx_CHAR_LOOKUP_t ), 1, fp );
}
if ( CHAR_LOOKUP_VERSION_VALUE > 100 )
{
for( i = 0; i < NUM_GEN_LOOKUPS; i ++ )
{
fwrite( & m_creatureLookups[i], sizeof( Fx_CHAR_LOOKUP_t ), 1, fp );
}
}
for( i = 0; i < NUM_MON_LOOKUPS; i ++ )
{
fwrite( &m_monLookups[i], sizeof( Fx_MON_LOOKUP_t ), 1, fp );
}
for( i = 0; i < MAX_COUNT_ANIM; i ++ )
{
fwrite( &m_aniInfo[i], sizeof( Fx_ANIM_INFO_t), 1, fp );
}
fclose( fp );
}
void FX_CCharLookupMng::LoadTableInfoFromFile( char* filename )
{
int i;
FILE* fp;
fp = fopen( filename, "rb" );
#ifdef _GTH_NEW_VERSION
char version [MAX_PATH];
fread ( version, strlen("VERSION"), 1, fp );
version [strlen("VERSION")] = NULL;
if ( strcmp ( version, "VERSION" ) )
{
m_fileVersion = 100;
fseek ( fp, 0L, SEEK_SET );
}
else
{
fread ( &m_fileVersion, sizeof(int), 1, fp );
}
#endif
for( i = 0; i < NUM_GEN_LOOKUPS; i ++ )
{
fread( & m_charLookups[i], sizeof( Fx_CHAR_LOOKUP_t ), 1, fp );
}
if ( m_fileVersion > 100 )
{
for( i = 0; i < NUM_GEN_LOOKUPS; i ++ )
{
fread( & m_creatureLookups[i], sizeof( Fx_CHAR_LOOKUP_t ), 1, fp );
}
}
for( i = 0; i < NUM_MON_LOOKUPS; i ++ )
{
fread( &m_monLookups[i], sizeof( Fx_MON_LOOKUP_t ), 1, fp );
}
for( i = 0; i < MAX_COUNT_ANIM; i ++ )
{
fread( &m_aniInfo[i], sizeof( Fx_ANIM_INFO_t), 1, fp );
}
fclose( fp );
}
void FX_CCharLookupMng::LoadTableInfoFromBuffer ( char *filename )
{
int i;
BYTE *pFileBuffer;
int offset = 0;
pFileBuffer = m_fileMng->ReadFileFromPack ( filename );
#ifdef _GTH_NEW_VERSION
char version [MAX_PATH];
GetDataFromBuffer ( (void *)version, pFileBuffer, strlen("VERSION"), offset );
version [strlen("VERSION")] = NULL;
if ( strcmp ( version, "VERSION" ) )
{
m_fileVersion = 100;
offset = 0;
}
else
{
GetDataFromBuffer ( (void *)&m_fileVersion, pFileBuffer, sizeof(int), offset );
}
#endif
for( i = 0; i < NUM_GEN_LOOKUPS; i ++ )
{
GetDataFromBuffer ( (void *)&m_charLookups [i], pFileBuffer, sizeof (Fx_CHAR_LOOKUP_t), offset );
}
if ( m_fileVersion > 100 )
{
for( i = 0; i < NUM_GEN_LOOKUPS; i ++ )
{
GetDataFromBuffer ( (void *)&m_creatureLookups [i], pFileBuffer, sizeof (Fx_CHAR_LOOKUP_t), offset );
}
}
for( i = 0; i < NUM_MON_LOOKUPS; i ++ )
{
GetDataFromBuffer ( (void *)&m_monLookups [i], pFileBuffer, sizeof (Fx_MON_LOOKUP_t), offset );
}
for( i = 0; i < MAX_COUNT_ANIM; i ++ )
{
GetDataFromBuffer ( (void *)&m_aniInfo [i], pFileBuffer, sizeof (Fx_ANIM_INFO_t), offset );
}
GTH_SAFE_FREE ( pFileBuffer );
return;
}
int FX_CCharLookupMng::GetItemAnimIDFromTable ( const int in_entityIdx,
const int in_itemIdx,
const int in_animIdx )
{
return m_charLookups [in_entityIdx].animset.anim_item [in_itemIdx].anim_type [in_animIdx];
}
int FX_CCharLookupMng::GetCommonAnimIDFromTable ( const int in_entityIdx,
const int in_animIdx )
{
return m_charLookups [in_entityIdx].animset.anim_common [in_animIdx];
}
int FX_CCharLookupMng::GetSkillAnimIDFromTable ( const int in_entityIdx,
const int in_animIdx )
{
return m_charLookups [in_entityIdx].animset.anim_skill [in_animIdx];
}
int FX_CCharLookupMng::GetAnimIDFromTable ( const int in_entityType,
const int in_entityIdx,
const int in_animType,
const int in_itemIdx,
const int in_animIdx,
const int in_charID,
const int in_isCreature )
{
Fx_CHAR_LOOKUP_t *lookup;
Fx_CHARACTER_t *pThisChar = &g_charManager ->m_Characters [in_charID];
if ( in_entityType == ENTITY_PC )
{
#ifdef _FX_CLIENT
if ( ! pThisChar ->isTransform )
{
#endif
if ( in_entityIdx < 0 ||
in_animType < ANIMTYPE_BYITEM ||
in_animType > ANIMTYPE_BYSKILL ||
in_itemIdx < 0 ||
in_animIdx < 0 )
{
return -1;
}
#ifdef _FX_CLIENT
}
#endif
}
else if ( in_entityType == ENTITY_MONSTER ||
in_entityType == ENTITY_NPC )
{
if ( in_entityIdx < 0 ||
in_itemIdx < 0 ||
in_animIdx < 0 )
{
return -1;
}
}
#ifdef _FX_CLIENT
int monAniSetIdx;
#endif
switch ( in_entityType )
{
case ENTITY_PC:
{
#ifdef _FX_CLIENT
if ( ! pThisChar ->isTransform )
{
#endif
if ( ! in_isCreature )
{
lookup = &m_charLookups [in_entityIdx];
}
else
{
lookup = &m_creatureLookups [in_entityIdx];
}
switch ( in_animType )
{
case ANIMTYPE_BYITEM:
return lookup ->animset.anim_item [in_itemIdx].anim_type [in_animIdx];
case ANIMTYPE_BYCOMMON:
return lookup ->animset.anim_common [in_animIdx];
case ANIMTYPE_BYSKILL:
return lookup ->animset.anim_skill [in_animIdx];
}
#ifdef _FX_CLIENT
}
else
{
monAniSetIdx = g_monsterTable [pThisChar ->transformEntityIdx].aniSetType;
if( monAniSetIdx < 0 || monAniSetIdx >= NUM_MON_LOOKUPS )
return -1;
if ( m_monLookups [monAniSetIdx].anim_monster [in_animIdx] < 0 )
{
return m_monLookups [monAniSetIdx].anim_monster [ANIM_ITEM_IDLE];
}
else
{
return m_monLookups [monAniSetIdx].anim_monster [in_animIdx];
}
}
#endif
}
#ifdef _FX_CLIENT
case ENTITY_MONSTER:
case ENTITY_NPC:
monAniSetIdx = g_monsterTable [in_entityIdx].aniSetType;
if( monAniSetIdx < 0 || monAniSetIdx >= NUM_MON_LOOKUPS )
return -1;
return m_monLookups [monAniSetIdx].anim_monster [in_animIdx];
#else
case ENTITY_MONSTER:
if( in_entityIdx < 0 || in_entityIdx >= NUM_MON_LOOKUPS )
return -1;
return m_monLookups [in_entityIdx].anim_monster [in_animIdx];
#endif
}
return -1;
}
int FX_CCharLookupMng::GetAnimTypeFromID ( const int in_entityType,
const int in_entityIdx,
const int in_animType,
const int in_itemIdx,
const int in_globalAnimIdx )
{
Fx_CHAR_LOOKUP_t *lookup = NULL;
int *searcher = NULL;
int counter = 0;
#ifdef _FX_CLIENT
int monAniSetIdx;
#endif
switch ( in_entityType )
{
case ENTITY_PC:
lookup = &m_charLookups [in_entityIdx];
switch ( in_animType )
{
case ANIMTYPE_BYITEM:
searcher = &lookup ->animset.anim_item [in_itemIdx].anim_type [0];
counter = MAX_ANIMCOUNT_TYPE;
case ANIMTYPE_BYCOMMON:
searcher = &lookup ->animset.anim_common [0];
counter = MAX_ANIMCOUNT_COMMON;
case ANIMTYPE_BYSKILL:
searcher = &lookup ->animset.anim_skill [0];
counter = MAX_ANIMCOUNT_SKILL;
}
#ifdef _FX_CLIENT
case ENTITY_MONSTER:
case ENTITY_NPC:
monAniSetIdx = g_monsterTable [in_entityIdx].aniSetType;
if( monAniSetIdx < 0 || monAniSetIdx >= NUM_MON_LOOKUPS )
return -1;
searcher = &m_monLookups [monAniSetIdx].anim_monster [0];
counter = MAX_ANIMCOUNT_TYPE;
#else
case ENTITY_MONSTER:
if( in_entityIdx < 0 || in_entityIdx >= NUM_MON_LOOKUPS )
return -1;
searcher = &m_monLookups [in_entityIdx].anim_monster [0];
counter = MAX_ANIMCOUNT_TYPE;
#endif
}
for ( int index = 0; \
index < counter; \
++index, ++searcher )
{
if ( in_globalAnimIdx == (*searcher) )
return index;
}
return -1;
}
int FX_CCharLookupMng::GetBoneIDFromTable ( const int in_entityType,
const int in_entityIdx )
{
if( in_entityIdx < 0 )
return -1;
#ifdef _FX_CLIENT
int monAniSetIdx;
#endif
switch ( in_entityType )
{
case ENTITY_PC:
if( in_entityIdx >= NUM_GEN_LOOKUPS )
return -1;
return m_charLookups [in_entityIdx].boneIdx;
#ifdef _FX_CLIENT
case ENTITY_MONSTER:
case ENTITY_NPC:
if( in_entityIdx >= MAX_NUMBER_OF_MONSTER_TABLE )
return -1;
monAniSetIdx = g_monsterTable[in_entityIdx].aniSetType;
if( monAniSetIdx >= NUM_MON_LOOKUPS )
return -1;
return m_monLookups [monAniSetIdx].boneIdx;
#else
case ENTITY_MONSTER:
if( in_entityIdx >= NUM_MON_LOOKUPS )
return -1;
return m_monLookups [in_entityIdx].boneIdx;
#endif
}
return -1;
}
int FX_CCharLookupMng::GetMonAnimIDFromTable ( const int in_entityIdx,
const int in_animIdx )
{
#ifdef _FX_CLIENT
int monAniSetIdx;
monAniSetIdx = g_monsterTable [in_entityIdx].aniSetType;
return m_monLookups [monAniSetIdx].anim_monster [in_animIdx];
#else
return m_monLookups [in_entityIdx].anim_monster [in_animIdx];
#endif
}
int FX_CCharLookupMng::GetIdleAnimation ( const int in_entityType,
const int in_entityIdx,
const int in_animType,
const int in_itemIdx )
{
return 0;
}
#ifdef _GTH_NEW_VERSION
int FX_CCharLookupMng::GetCreatureItemAnimIDFromTable ( const int in_entityIdx,
const int in_itemIdx,
const int in_animIdx )
{
return m_creatureLookups [in_entityIdx].animset.anim_item [in_itemIdx].anim_type [in_animIdx];
}
int FX_CCharLookupMng::GetCreatureCommonAnimIDFromTable ( const int in_entityIdx,
const int in_animIdx )
{
return m_creatureLookups [in_entityIdx].animset.anim_common [in_animIdx];
}
int FX_CCharLookupMng::GetCreatureSkillAnimIDFromTable ( const int in_entityIdx,
const int in_animIdx )
{
return m_creatureLookups [in_entityIdx].animset.anim_skill [in_animIdx];
}
#endif | C++ |
#ifndef _BONE_MANAGER_HF93H018H203
#define _BONE_MANAGER_HF93H018H203
typedef struct
{
FX_CSkel skeleton;
} SKELETON_t;
class FX_CSkelManager
{
public:
FX_CSkelManager();
~FX_CSkelManager() {};
public:
SKELETON_t m_Skels [MAX_COUNT_SKEL];
int m_iNumSkels;
int m_iBoneLookUp [MAX_COUNT_SKEL][MAX_COUNT_BONE];
Fx_SKEL_BUF_t m_SkelBuffer [MAX_COUNT_SKEL];
FX_CBoneManager *m_pBoneManager;
CScript *m_pScript;
CFileMng *m_fileMng;
public:
bool LoadSkelList();
void Cleanup();
int GetLocalID ( const int iGlobalID, const int iBoneID );
void MakeLookupTable();
void SetBoneManager ( FX_CBoneManager *boneManager ) { m_pBoneManager = boneManager; }
void SetScript ( CScript *script ) { m_pScript = script; }
void SetFileManager ( CFileMng *fileMng ) { m_fileMng = fileMng; }
private:
bool LoadSkel ( char *pszSkelName,
unsigned int &iSkelID );
};
#endif | C++ |
#ifndef _FX_AURA_MANAGER_H_ALKJSHD48VU4HRUA
#define _FX_AURA_MANAGER_H_ALKJSHD48VU4HRUA
class FX_CAuraManager
{
public:
FX_CAuraManager ();
~FX_CAuraManager ();
public:
int m_numAuraShader;
DIFFUSETEXVERTEX m_PreVB [SIZE_PREVB_AURA];
WORD m_PreIB [(AURA_MAX_DIVIDE + 1) * (MAX_AURA_IN_CHAR - 1) * 6];
float m_texfactor;
int m_numVertexToDraw;
int m_numIndexToDraw;
FX_CCharManager *m_pCharManager;
CD3DTextureMng *m_texMng;
CScript *m_pScript;
CD3DRender *m_D3DRender;
FX_CCharShaderMng *m_pCharShaderMng;
LPDIRECT3DDEVICE8 m_pd3dDevice;
FX_CAuraRenderer *m_auraRenderer;
public:
void Render ( Fx_CHARACTER_t *in_char, int *in_numprims, const int in_shaderIdx, const int in_numUsed );
void SetDevice ( const LPDIRECT3DDEVICE8 device );
void SetScript ( CScript *script ) { m_pScript = script; };
void SetCharManager ( FX_CCharManager *charManager ) { m_pCharManager = charManager; };
void SetTexManager ( CD3DTextureMng *texMng ) { m_texMng = texMng; };
void SetRenderer ( CD3DRender *d3dRender );
void SetShaderMng ( CShaderMng *shaderMng );
void SetCharShaderMng ( FX_CCharShaderMng *charShaderMng ) { m_pCharShaderMng = charShaderMng; };
bool PrepareRenderBuffers();
bool ReleaseRenderBuffers();
int Update ( float &in_update, const float in_cur );
void UpdatePos ( AURA_t &in_aura, const vec3_t in_pttop, const vec3_t in_ptbottom );
void ResetUpdateTime ( int in_index );
void SetInitialPos ( AURA_t *in_aura, const vec3_t in_pttop, const vec3_t in_ptbottom );
void FadeAura ( AURA_t &in_aura );
bool MakePreVertexBuffer ( const AURA_t *in_aura );
void MakePreIndexBuffer ();
void Cleanup ();
};
#endif | C++ |
#pragma warning( disable : 4786 )
#include <assert.h>
#include <algorithm>
#ifdef _FX_CLIENT
#include "../../global_def.h"
#include "../Common.h"
#define g_temporaryPanelPos GLOBAL_VEC3_1
#define g_temporaryPanelBBox GLOBAL_BBOX
#define g_worldPosPelvis GLOBAL_DXVEC3_1
#define g_afterTransform GLOBAL_DXVEC4_1
#define g_camCharDistance GLOBAL_DXVEC3_2
#define g_screenPosition GLOBAL_DXVEC3_3
#define g_cdfinalangle GLOBAL_VEC3_1
#define g_cdconvertedvector GLOBAL_VEC3_2
#define g_cdpoint GLOBAL_DXVEC3_1
#define g_cdnormal GLOBAL_DXVEC3_2
#define g_cdoutpoint GLOBAL_DXVEC4_1
#define g_inverse GLOBAL_DXMATRIX_1
#define g_xformed_start_pre GLOBAL_DXVEC4_1
#define g_xformed_end_pre GLOBAL_DXVEC4_2
#define g_xformed_start GLOBAL_DXVEC3_8
#define g_xformed_end GLOBAL_DXVEC3_9
#define g_collidedPoint GLOBAL_DXVEC3_10
#define g_collidedPointNormal GLOBAL_DXVEC3_11
#define g_line_mid GLOBAL_DXVEC3_1
#define g_line_fquarter GLOBAL_DXVEC3_2
#define g_line_bquarter GLOBAL_DXVEC3_3
#define g_expansion_pre GLOBAL_DXVEC3_4
#define g_expansion GLOBAL_DXVEC3_5
#define g_displace GLOBAL_DXVEC3_6
#define g_thisPoint GLOBAL_DXVEC3_7
#define g_charBBox GLOBAL_BBOX
void FX_CCharManager::ChangeAnimation ( const int iCharID,
const int aniSetType,
const int aniSetIndex,
const int aniSetID,
const float *in_animSpeed,
const bool in_forceChage )
{
Fx_CHARACTER_t* pThisChar = &m_Characters [iCharID];
Fx_ANIM_INFO_t *nextState;
int nextIdx;
if ( ( aniSetType < 0 ) ||
( aniSetIndex < 0 ) ||
( aniSetID < 0 ) )
return;
nextIdx = m_pCharLookupMng ->GetAnimIDFromTable ( pThisChar->entityType, pThisChar->tableIdx, aniSetType, aniSetIndex, aniSetID, pThisChar->ID );
if( nextIdx < 0 || nextIdx > MAX_COUNT_ANIM )
return;
nextState = &m_pCharLookupMng ->m_aniInfo [nextIdx];
if ( ( true == pThisChar ->ani_curState.type.changable ) ||
in_forceChage )
{
if ( pThisChar ->ani_elapsed == 0.0f )
MakeInterpolator( pThisChar, 0.05f, pThisChar->ani_curIdx, nextIdx, INTERPOLATE_NORMAL );
else
MakeInterpolator( pThisChar, 0.05f, pThisChar->ani_curIdx, nextIdx, INTERPOLATE_USE_CURFRAME );
pThisChar ->ani_nextIdx = -1;
pThisChar ->ani_nextGroup = FX_ANIM_GROUP_NULL;
pThisChar ->ani_option = ANIMOPTION_START_NEW_ANIM;
pThisChar ->ani_curIdx = nextIdx;
pThisChar ->ani_curGroup = nextState ->groupID;
pThisChar ->ani_curState.value = nextState ->state.value;
pThisChar ->ani_curSetType = aniSetType;
if( aniSetType == ANIMTYPE_BYITEM ) pThisChar ->ani_curItemSetIndex = aniSetIndex;
pThisChar ->ani_curSetID = aniSetID;
pThisChar ->ani_fraction = 0.0f;
if ( ( in_animSpeed != NULL ) )
{
SetAnimationSpeedInSec ( pThisChar, *in_animSpeed, false );
pThisChar ->stat_attackTime = (*in_animSpeed);
}
else
{
pThisChar ->ani_curSpeed = 1.0f;
pThisChar ->ani_curRSpeed = 1.0f;
}
}
else
{
pThisChar ->ani_nextIdx = nextIdx;
pThisChar ->ani_nextGroup = nextState ->groupID;
pThisChar ->ani_nextState.value = nextState ->state.value;
pThisChar->ani_nextSetType = aniSetType;
pThisChar->ani_nextItemSetIndex = aniSetIndex;
pThisChar->ani_nextSetID = aniSetID;
if ( ( in_animSpeed != NULL ) )
{
SetAnimationSpeedInSec ( pThisChar, *in_animSpeed, true );
}
else
{
pThisChar ->ani_nextSpeed = 1.0f;
pThisChar ->ani_nextRSpeed = 1.0f;
}
}
return;
}
float FX_CCharManager::GetCharPanelScreenPos ( Fx_CHARACTER_t *in_char,
vec3_t out_pos )
{
float w;
g_temporaryPanelPos [0] = in_char ->position [0];
g_temporaryPanelPos [1] = in_char ->position [1];
g_temporaryPanelPos [2] = in_char ->position [2] + in_char ->attr_tall;
w = g_camera .GetTransformMatrix() ->Transform ( out_pos, g_temporaryPanelPos );
out_pos [0] = ( 1.0f + out_pos [0] ) * g_cursor->m_viewport.Width * 0.5f;
out_pos [1] = ( 1.0f - out_pos [1] ) * g_cursor->m_viewport.Height * 0.5f;
return( w );
}
Fx_CHARACTER_t *FX_CCharManager::SearchCursorEntityNeo2 ( const vec3_t in_camPos,
const vec3_t in_camAngle,
matrix4x4_t *in_camTransMat,
const float in_minSquareDist,
const vec2_t in_mousePos,
const vec2_t in_viewportSize )
{
Fx_CHARACTER_t *thisChar = NULL;
Fx_CHARACTER_t *firstCandidate = NULL;
Fx_CHARACTER_t *thisCandidate = NULL;
Fx_CHARACTER_t *closestCandidate = NULL;
bool isFirstCandidate = true;
bboxf_t bbox;
float halfWidth, halfHeight;
int index;
float red_ratio;
float diff;
float angle;
float minx, maxx, miny, maxy, minz, maxz;
float sqr_length;
float trival;
float ang_diff;
const float DISCARD_X = 100.0f;
const float DISCARD_Y = 100.0f;
m_minSquareDist = 100000000.0f;
thisChar = &m_Characters [0];
for ( index = 0; \
index < m_iNumCharacters; \
++index, ++thisChar )
{
if ( thisChar ->flag_culled ) continue;
g_worldPosPelvis [0] = thisChar ->stat_disp_x;
g_worldPosPelvis [1] = thisChar ->stat_disp_y;
g_worldPosPelvis [2] = 0.0f;
D3DXVec3Transform ( (D3DXVECTOR4 *)g_afterTransform, (D3DXVECTOR3 *)g_worldPosPelvis, (D3DXMATRIX *)&thisChar ->stat_matTransform );
VectorCopy ( thisChar ->ren_xformedPelvisPos, g_afterTransform );
VectorSubtract ( g_camCharDistance, thisChar ->ren_xformedPelvisPos, in_camPos );
thisChar ->ren_squareDist = VectorDotProduct ( g_camCharDistance, g_camCharDistance );
if ( thisChar ->ren_squareDist > m_minSquareDist )
continue;
if ( thisChar ->flag_disappear ) continue;
if( thisChar ->entityType != ENTITY_PC )
{
if( g_cgv.myCharacterInfo->pcJob == J_STRANGER )
{
if( thisChar->stat_alive > MON_ALIVE_STATE_CORPSE ) continue;
}
else
{
if( thisChar->stat_alive >= MON_ALIVE_STATE_CORPSE ) continue;
}
}
if( !GTH_RenderGM( thisChar ) ) continue;
thisChar ->ren_closerChar = NULL;
thisChar ->ren_fartherChar = NULL;
if ( ! isFirstCandidate )
{
thisCandidate = firstCandidate;
if ( thisChar ->ren_squareDist < firstCandidate ->ren_squareDist )
{
while (1)
{
if ( thisCandidate ->ren_squareDist < thisChar ->ren_squareDist )
{
if ( thisCandidate ->ren_fartherChar )
{
thisChar ->ren_fartherChar = thisCandidate ->ren_fartherChar;
thisCandidate ->ren_fartherChar ->ren_closerChar = thisChar;
}
thisCandidate ->ren_fartherChar = thisChar;
thisChar ->ren_closerChar = thisCandidate;
break;
}
else if ( thisCandidate ->ren_closerChar == NULL )
{
thisCandidate ->ren_closerChar = thisChar;
thisChar ->ren_fartherChar = thisCandidate;
closestCandidate = thisChar;
break;
}
thisCandidate = thisCandidate ->ren_closerChar;
}
}
else
{
while (1)
{
if ( thisCandidate ->ren_squareDist > thisChar ->ren_squareDist )
{
if ( thisCandidate ->ren_closerChar )
{
thisChar ->ren_closerChar = thisCandidate ->ren_closerChar;
thisCandidate ->ren_closerChar ->ren_fartherChar = thisChar;
}
thisCandidate ->ren_closerChar = thisChar;
thisChar ->ren_fartherChar = thisCandidate;
break;
}
else if ( thisCandidate ->ren_fartherChar == NULL )
{
thisCandidate ->ren_fartherChar = thisChar;
thisChar ->ren_closerChar = thisCandidate;
break;
}
thisCandidate = thisCandidate ->ren_fartherChar;
}
}
}
else
{
firstCandidate = thisChar;
closestCandidate = thisChar;
isFirstCandidate = false;
}
}
if ( closestCandidate == NULL ) return NULL;
halfWidth = (float)in_viewportSize [0] * 0.5f;
halfHeight = (float)in_viewportSize [1] * 0.5f;
float ratioFactor = 0.5f / (float)tan (g_camera.m_projectParm.fov / g_camera.m_projectParm.aspect * 0.5f * FX_DEGTORAD);
thisChar = closestCandidate;
do
{
red_ratio = in_viewportSize [1] * ratioFactor / (float)sqrt (thisChar ->ren_squareDist);
in_camTransMat ->Transform ( g_screenPosition, (float *)&thisChar ->ren_xformedPelvisPos );
g_screenPosition [0] = ( 1.0f + g_screenPosition [0] ) * halfWidth;
g_screenPosition [1] = ( 1.0f - g_screenPosition [1] ) * halfHeight;
diff = fabs ( in_mousePos [1] - g_screenPosition [1] );
if ( diff > DISCARD_Y * red_ratio ) goto SKIP;
diff = fabs ( in_mousePos [0] - g_screenPosition [0] );
if ( diff > DISCARD_X * red_ratio ) goto SKIP;
GetBoundCharPreTransform( thisChar, bbox );
diff *= diff;
ang_diff = in_camAngle [YAW] - ( thisChar ->angles [YAW] - 90.0f );
if ( ang_diff < 0.0f ) ang_diff += 360.0f;
minx = fabs (thisChar ->stat_disp_x - bbox [0]);
maxx = fabs (thisChar ->stat_disp_x - bbox [3]);
miny = fabs (thisChar ->stat_disp_y - bbox [1]);
maxy = fabs (thisChar ->stat_disp_y - bbox [4]);
if ( ( ang_diff >= 0.0f ) &&
( ang_diff < 90.0f ) )
{
if ( in_mousePos [0] < g_screenPosition [0] )
{
sqr_length = maxx*maxx + miny*miny;
angle = (float)atan2 ( miny, maxx ) + ang_diff * FX_DEGTORAD;
trival = (float)fabs (sin (angle)) * red_ratio;
if ( diff > ( sqr_length * trival * trival ) )
goto SKIP;
}
else
{
sqr_length = minx*minx + maxy*maxy;
angle = (float)atan2 ( maxy, minx ) + ang_diff * FX_DEGTORAD;
trival = (float)fabs (sin (angle)) * red_ratio;
if ( diff > ( sqr_length * trival * trival ) )
goto SKIP;
}
}
else if ( ( ang_diff >= 90.0f ) &&
( ang_diff < 180.0f ) )
{
if ( in_mousePos [0] < g_screenPosition [0] )
{
sqr_length = maxx*maxx + maxy*maxy;
angle = (float)atan2 ( maxy, maxx ) - ang_diff * FX_DEGTORAD;
trival = (float)fabs (sin (angle)) * red_ratio;
if ( diff > ( sqr_length * trival * trival ) )
goto SKIP;
}
else
{
sqr_length = minx*minx + miny*miny;
angle = (float)atan2 ( miny, minx ) - ang_diff * FX_DEGTORAD;
trival = (float)fabs (sin (angle)) * red_ratio;
if ( diff > ( sqr_length * trival * trival ) )
goto SKIP;
}
}
else if ( ( ang_diff >= 180.0f ) &&
( ang_diff < 270.0f ) )
{
if ( in_mousePos [0] < g_screenPosition [0] )
{
sqr_length = minx*minx + maxy*maxy;
angle = (float)atan2 ( maxy, minx ) + ang_diff * FX_DEGTORAD;
trival = (float)fabs (sin (angle)) * red_ratio;
if ( diff > ( sqr_length * trival * trival ) )
goto SKIP;
}
else
{
sqr_length = maxx*maxx + miny*miny;
angle = (float)atan2 ( miny, maxx ) + ang_diff * FX_DEGTORAD;
trival = (float)fabs (sin (angle)) * red_ratio;
if ( diff > ( sqr_length * trival * trival ) )
goto SKIP;
}
}
else
{
if ( in_mousePos [0] < g_screenPosition [0] )
{
sqr_length = minx*minx + miny*miny;
angle = (float)atan2 ( miny, minx ) - ang_diff * FX_DEGTORAD;
trival = (float)fabs (sin (angle)) * red_ratio;
if ( diff > ( sqr_length * trival * trival ) )
goto SKIP;
}
else
{
sqr_length = maxx*maxx + maxy*maxy;
angle = (float)atan2 ( maxy, maxx ) - ang_diff * FX_DEGTORAD;
trival = (float)fabs (sin (angle)) * red_ratio;
if ( diff > ( sqr_length * trival * trival ) )
goto SKIP;
}
}
diff = fabs ( in_mousePos [1] - g_screenPosition [1] );
diff *= diff;
ang_diff = -in_camAngle [PITCH];
if ( ang_diff < 0.0f ) ang_diff += 180.0f;
minz = fabs (thisChar ->stat_height - bbox [2]);
maxz = fabs (thisChar ->stat_height - bbox [5]);
if ( ( in_camAngle [PITCH] >= -90.0f ) &&
( in_camAngle [PITCH] < 0.0f ) )
{
if ( in_mousePos [1] < g_screenPosition [1] )
{
sqr_length = maxy*maxy + maxz*maxz;
angle = (float)atan2 ( maxz, maxy ) + ang_diff * FX_DEGTORAD;
trival = (float)sin (angle) * red_ratio;
if ( diff > ( sqr_length * trival * trival ) )
goto SKIP;
}
else
{
sqr_length = minz*minz + miny*miny;
angle = (float)atan2 ( minz, miny ) + ang_diff * FX_DEGTORAD;
trival = (float)sin (angle) * red_ratio;
if ( diff > ( sqr_length * trival * trival ) )
goto SKIP;
}
}
else
{
if ( in_mousePos [1] < g_screenPosition [1] )
{
sqr_length = miny*miny + maxz*maxz;
angle = (float)atan2 ( maxz, miny ) - ang_diff * FX_DEGTORAD;
trival = (float)sin (angle) * red_ratio;
if ( diff > ( sqr_length * trival * trival ) )
goto SKIP;
}
else
{
sqr_length = minz*minz + maxy*maxy;
angle = (float)atan2 ( minz, maxy ) - ang_diff * FX_DEGTORAD;
trival = (float)sin (angle) * red_ratio;
if ( diff > ( sqr_length * trival * trival ) )
goto SKIP;
}
}
m_minSquareDist = thisChar ->ren_squareDist;
if( thisChar->idxOnServer == g_cgv.myPCIdxOnServer && thisChar->entityType == ENTITY_PC )
{
if( g_cgv.state == CLIENT_GAME_PROCESS ) return NULL;
}
return thisChar;
SKIP:
thisChar = thisChar ->ren_fartherChar;
} while ( thisChar != NULL );
return NULL;
}
float FX_CCharManager::GetAnimFraction ( Fx_CHARACTER_t *in_char )
{
return in_char ->ani_fraction;
}
void FX_CCharManager::EquipAllItem ( const int iCharID )
{
int i, itemTableIdx;
const Fx_CHARACTER_t *pNewChar = &m_Characters [iCharID];
for ( i = 0; \
i < pNewChar ->equipNumber; \
i++ )
{
itemTableIdx = pNewChar ->equipment [i];
EquipItem ( iCharID, &g_itemTable [itemTableIdx] );
}
}
void FX_CCharManager::SetAnimationSpeedInSec ( Fx_CHARACTER_t *in_char,
const float in_milisecond, int isNext )
{
if( !isNext )
{
in_char ->ani_curSpeed = in_milisecond / 1000.0f * m_pAnimManager ->m_Anims [in_char ->ani_curIdx].animation.m_rcptotalTime;
in_char ->ani_curRSpeed = 1.0f / in_char ->ani_curSpeed;
}
else
{
in_char ->ani_nextSpeed = in_milisecond / 1000.0f * m_pAnimManager ->m_Anims [in_char ->ani_nextIdx].animation.m_rcptotalTime;
in_char ->ani_nextRSpeed = 1.0f / in_char ->ani_nextSpeed;
}
return;
}
void FX_CCharManager::SetTargetID ()
{
int index, subindex;
Fx_CHARACTER_t *thisChar = &m_Characters [0];
for ( index = 0; \
index < m_iNumCharacters; \
++index, ++thisChar )
{
for ( subindex = 0; \
subindex < m_iNumCharacters; \
++subindex )
{
if ( m_Characters [subindex].idxOnServer == thisChar ->targetIdx )
{
thisChar ->targetID = subindex;
break;
}
}
}
return;
}
void FX_CCharManager::AddEffect ( int type, int in_effectID, Fx_CHARACTER_t *in_char, float in_zpos )
{
vec3_t origin, target;
int targetID;
Fx_CHARACTER_t *defender = NULL;
targetID = g_GameTarget.GTH_GetTargetClientID( in_char );
defender = g_GameTarget.GTH_GetTargetPointer( in_char );
if( targetID < 0 || defender == NULL ) return;
switch( type )
{
case FX_CCharManager::EFFECT_NORMAL :
if( defender == NULL ) return;
VectorCopy( origin, in_char->position );
VectorCopy( target, defender->position );
origin[2] += in_zpos;
target[2] += in_zpos;
g_effectMng ->Add( GTH_EFFECT_CLASS_MODEL, 0, target , NULL, NULL, -20.0f ,
in_char->entityType, in_char->idxOnServer, defender->entityType, defender->idxOnServer );
break;
case FX_CCharManager::EFFECT_MISSILE :
if( defender == NULL ) return;
VectorCopy( origin, in_char->position );
VectorCopy( target, defender->position );
origin[2] += in_char->stat_height;
target[2] += defender->stat_height;
g_effectMng ->Add( GTH_EFFECT_CLASS_MULTI_MODEL, in_effectID, origin, target, NULL, 0.0f,
in_char->entityType, in_char->idxOnServer, defender->entityType, defender->idxOnServer, 0, false, in_char ->idxOnServer );
break;
case FX_CCharManager::EFFECT_BASIC_ATTACK_EFFECT:
{
if( defender == NULL ) return;
VectorCopy( origin, in_char->position );
VectorCopy( target, defender->position );
target[2] -= defender->stat_height;
g_effectMng ->Add( (GTH_EFFECT_CLASS_TYPE)GTH_EFFECT_CLASS_MULTI_MODEL, in_effectID, origin, target, NULL, 0.0f,
in_char->entityType, in_char->idxOnServer, defender->entityType, defender->idxOnServer, 0, false );
} break;
}
return;
}
void FX_CCharManager::SetTrembling ( const vec3_t in_position,
const float in_preperation,
const float in_duration,
const float in_power )
{
if ( ! m_tbUse ) return;
const float POWER_CONSTANT = 0.00001f;
m_tbPrepare = true;
m_tbDuration = in_duration;
vec3_t distance;
VectorSubtract ( distance, m_Characters [0].position, in_position );
float sqr_length = VectorDotProduct ( distance, distance ) * POWER_CONSTANT;
m_tbPower = in_power / (in_power + sqr_length);
m_tbPreperationDuration = in_preperation;
m_tbStartTime = g_timer .GetAppTime ();
return;
}
void FX_CCharManager::StopTrembling ()
{
if ( ! m_tbDo || ! m_tbUse ) return;
m_tbDo = false;
VectorCopy ( g_camera .m_position, m_tbOriginalCamPos );
return;
}
void FX_CCharManager::CheckTrembling ()
{
if ( ! m_tbUse ) return;
if ( m_tbPrepare )
{
if ( ( g_timer .GetAppTime () - m_tbStartTime ) > m_tbPreperationDuration )
{
m_tbPrepare = false;
m_tbDo = true;
VectorCopy ( m_tbOriginalCamPos, g_camera .m_position );
m_tbStartTime = g_timer .GetAppTime ();
}
}
else if ( m_tbDo )
{
if ( ( g_timer .GetAppTime () - m_tbStartTime ) > m_tbDuration )
{
StopTrembling ();
}
}
return;
}
int FX_CCharManager::SetCharacterSpeed ( Fx_CHARACTER_t *in_char,
float in_percent )
{
if ( in_percent <= 0 )
{
StopAnimation ( in_char ->ID, false );
return 1;
}
StopAnimation ( in_char ->ID, true );
in_char ->ren_oldGeneralSpeed = in_char ->ren_generalSpeed;
in_char ->ren_generalSpeed = in_percent;
return 0;
}
void FX_CCharManager::RenderShadow ()
{
if ( ! m_drawShadows ) return;
m_pd3dDevice ->SetRenderState ( D3DRS_LIGHTING, FALSE );
m_pd3dDevice ->SetRenderState ( D3DRS_SRCBLEND, D3DBLEND_INVSRCCOLOR );
m_pd3dDevice ->SetRenderState ( D3DRS_DESTBLEND, D3DBLEND_DESTCOLOR );
m_pd3dDevice ->SetRenderState ( D3DRS_ALPHAREF, 0x000000FE );
m_pd3dDevice ->SetRenderState ( D3DRS_ALPHAFUNC, D3DCMP_GREATER );
m_pd3dDevice ->SetTextureStageState ( 0, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP );
m_pd3dDevice ->SetTextureStageState ( 0, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP );
g_pApp ->m_worldBSPs [g_pApp ->m_currWorld] ->SetDecalBuffer();
int index;
Fx_CHARACTER_t *thisChar = &m_Characters [0];
for ( index = 0; \
index < m_iNumCharacters; \
++index, ++thisChar )
{
if ( ! thisChar->ren_renderThisFrame ) continue;
if ( thisChar ->flag_disappear ) continue;
MakeShadow( thisChar );
}
ITOR_LIST_CREATURE itor;
for ( itor = m_usedCreatureList.begin(); \
itor != m_usedCreatureList.end(); \
++itor )
{
MakeShadow( (*itor) );
}
m_pd3dDevice ->SetRenderState ( D3DRS_ALPHAREF, 0x00000000 );
}
void FX_CCharManager::MakeShadow ( Fx_CHARACTER_t *in_char )
{
vec3_t lightAngle;
vec3_t lightVector;
vec3_t firstCP;
vec3_t secondCP;
vec2_t firstPCP;
vec2_t secondPCP;
vec2_t centerPoint;
float dispPS;
vec3_t sunAngle;
GetBoundCharPreTransform( in_char, g_charBBox );
const float OVERSIZE = 10000.0f;
if ( ( fabs ( g_charBBox[ 5 ] - g_charBBox[ 2 ] ) > OVERSIZE ) ||
( fabs ( g_charBBox[ 4 ] - g_charBBox[ 1 ] ) > OVERSIZE ) ||
( fabs ( g_charBBox[ 3 ] - g_charBBox[ 0 ] ) > OVERSIZE ) )
return;
VectorToAngles ( g_pApp ->m_mapInfos [0].sunAngle, sunAngle );
lightAngle[PITCH] = 500.0f;
lightAngle [YAW] = sunAngle [YAW] - ( in_char ->angles [YAW] + 90.0f ) - 180.0f;
lightAngle [ROLL] = in_char ->angles [ROLL];
#ifdef _DEBUG
if ( in_char ->ID == 0 )
{
g_chatManager ->DPrint ( 500, 520, "Light Yaw : %.2f", sunAngle [YAW] );
g_chatManager ->DPrint ( 500, 540, "Char Yaw : %.2f", in_char ->angles [YAW] );
}
#endif
if ( lightAngle [YAW] < -360.0f ) lightAngle [YAW] += 720;
else if ( lightAngle [YAW] < 0 ) lightAngle [YAW] += 360;
AngleToVector ( lightAngle, lightVector );
assert ( ( lightAngle [YAW] >= 0 ) &&
( lightAngle [YAW] < 360 ) );
vec3_t sizeVector;
VectorSubtract ( sizeVector, &g_charBBox [3], &g_charBBox [0] );
VectorScale ( sizeVector, sizeVector, 0.3f );
VectorSubtract ( &g_charBBox [0], &g_charBBox [0], sizeVector );
VectorAdd ( &g_charBBox [3], &g_charBBox [3], sizeVector );
if ( lightAngle [YAW] < 90 )
{
firstCP [0] = g_charBBox [3];
firstCP [1] = g_charBBox [4];
secondCP [0] = g_charBBox [0];
secondCP [1] = g_charBBox [1];
}
else if ( lightAngle [YAW] < 180 )
{
firstCP [0] = g_charBBox [0];
firstCP [1] = g_charBBox [4];
secondCP [0] = g_charBBox [3];
secondCP [1] = g_charBBox [1];
}
else if ( lightAngle [YAW] < 270 )
{
firstCP [0] = g_charBBox [0];
firstCP [1] = g_charBBox [1];
secondCP [0] = g_charBBox [3];
secondCP [1] = g_charBBox [4];
}
else if ( lightAngle [YAW] < 360 )
{
firstCP [0] = g_charBBox [3];
firstCP [1] = g_charBBox [1];
secondCP [0] = g_charBBox [0];
secondCP [1] = g_charBBox [4];
}
firstCP [2] = g_charBBox [2];
secondCP [2] = g_charBBox [5];
float param;
param = ( 2.0f - firstCP [2] ) / lightVector [2];
firstPCP [0] = lightVector [0] * param + firstCP [0];
firstPCP [1] = lightVector [1] * param + firstCP [1];
param = ( 2.0f - secondCP [2] ) / lightVector [2];
secondPCP [0] = lightVector [0] * param + secondCP [0];
secondPCP [1] = lightVector [1] * param + secondCP [1];
centerPoint [0] = ( firstPCP [0] + secondPCP [0] ) * 0.5f;
centerPoint [1] = ( firstPCP [1] + secondPCP [1] ) * 0.5f;
float diffX, diffY;
diffX = fabs ( firstPCP [0] - secondPCP [0] );
diffY = fabs ( firstPCP [1] - secondPCP [1] );
dispPS = ( diffX > diffY ) ? ( diffX * 0.5f ) : ( diffY * 0.5f );
D3DXMatrixLookAtLH ( (D3DXMATRIX *)&m_shadowView,
&D3DXVECTOR3 ( centerPoint [0], centerPoint [1], 100.0f ),
&D3DXVECTOR3 ( centerPoint [0], centerPoint [1], 0.0f ),
&D3DXVECTOR3 ( 0.0f, -1.0f, 0.0f ) );
D3DXMatrixOrthoOffCenterLH ( (D3DXMATRIX *)&m_shadowProj,
-dispPS, dispPS,
-dispPS, dispPS,
0, 1000 );
float tempLightHeight = 1400.0f;
float divider = tempLightHeight / lightVector [2];
VectorScale ( lightVector, lightVector, divider );
VectorCopy ( m_shadowLightVector, lightVector );
m_shadowPlane [3] = in_char ->stat_height;
D3DXVec4Normalize ( (D3DXVECTOR4 *)&m_shadowNormalizedPlane, (D3DXVECTOR4 *)&m_shadowPlane );
D3DXMatrixShadow ( (D3DXMATRIX *)&m_shadowMatrix,
(D3DXVECTOR4 *)&m_shadowLightVector,
(D3DXPLANE *)&m_shadowNormalizedPlane );
m_pd3dDevice ->SetRenderTarget ( m_shadowSurface, NULL );
m_D3DRender ->SetTransform ( D3DTS_WORLD, &m_shadowMatrix );
m_D3DRender ->SetTransform ( D3DTS_VIEW, &m_shadowView );
m_D3DRender ->SetTransform ( D3DTS_PROJECTION, &m_shadowProj );
m_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
m_pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );
m_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CW );
m_pd3dDevice->SetRenderState( D3DRS_ZENABLE, FALSE );
m_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_ARGB( 0, 0, 0, 0 ), 1.0f, 0 );
m_pd3dDevice->SetTexture( 0, NULL );
m_D3DRender->SetVertexShader( GTH_CHAR_FORMAT );
m_pSkinRenderer->RenderShadow( in_char, m_pSkinManager );
m_pItemManager->m_pItemRenderer->RenderShadow( in_char, m_pItemManager, m_pBoneManager, &m_shadowMatrix );
m_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
m_pd3dDevice->SetVertexShader( D3DFVF_SHADOWTEST );
m_pd3dDevice->SetStreamSource( 0, m_shadowVB, sizeof( SHADOWTESTFORMAT ) );
m_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, 8 );
m_pd3dDevice->SetRenderTarget( m_backBuffer, m_zBuffer );
float scaler = dispPS / ( SHADOW_TEX_DIMENSION * 0.5f );
vec2_t newCenter;
float angle = deg2rad ( lightAngle [YAW] - sunAngle [YAW] + 180.0f );
float cosval = cos ( angle );
float sinval = sin ( angle );
newCenter [0] = cosval * centerPoint [0] + sinval * centerPoint [1];
newCenter [1] = -sinval * centerPoint [0] + cosval * centerPoint [1];
D3DXMatrixTranslation ( (D3DXMATRIX *)&m_shadowTranslation, newCenter [0], newCenter [1], -(in_char ->stat_height - 2.0f) );
D3DXMatrixMultiply ( (D3DXMATRIX *)&m_shadowMatrix, (D3DXMATRIX *)&in_char ->stat_matTransform, (D3DXMATRIX *)&m_shadowTranslation );
vec3_t newOrigin;
float newSize;
newOrigin [0] = in_char ->position [0] + newCenter [0];
newOrigin [1] = in_char ->position [1] + newCenter [1];
newOrigin [2] = in_char ->position [2] - in_char ->stat_height;
newSize = dispPS * m_sqrtTwo;
float charHeight = g_charBBox [5] - g_charBBox [2];
float maxHeightLimit = in_char ->position [2] + charHeight;
float minHeightLimit = in_char ->position [2] - 0.5f * charHeight;
CBSP* pBsp = g_pApp ->m_worldBSPs [g_pApp ->m_currWorld];
pBsp->SetDecalInit((matrix4x4_t *)&m_shadowMatrix,
lightVector,
g_pApp ->m_mapInfos [0].sunAngle,
dispPS,
minHeightLimit,
maxHeightLimit);
int size = 0;
if (!pBsp->RenderProjectiveShadowNeo ( newSize, newOrigin, m_shadowVBNeo, size ))
{
m_pd3dDevice ->SetTransform ( D3DTS_VIEW, (D3DXMATRIX *)&g_camera .m_viewMat );
m_pd3dDevice ->SetTransform ( D3DTS_PROJECTION, (D3DXMATRIX *)&g_camera .m_projMat );
return;
}
m_pd3dDevice ->SetTransform ( D3DTS_WORLD, (D3DXMATRIX *)&IDENTITY_MATRIX );
m_pd3dDevice ->SetTransform ( D3DTS_VIEW, (D3DXMATRIX *)&g_camera .m_viewMat );
m_pd3dDevice ->SetTransform ( D3DTS_PROJECTION, (D3DXMATRIX *)&g_camera .m_projMat );
m_pd3dDevice ->SetRenderState ( D3DRS_CULLMODE, D3DCULL_CCW );
m_pd3dDevice ->SetRenderState ( D3DRS_ALPHABLENDENABLE, TRUE );
m_pd3dDevice ->SetRenderState ( D3DRS_ALPHATESTENABLE, TRUE );
m_pd3dDevice ->SetRenderState ( D3DRS_ZENABLE, TRUE );
m_pd3dDevice ->SetTexture ( 0, m_shadowTexture );
m_D3DRender ->SetStreamSource ( 0, m_shadowVBNeo ->GetD3DVertexBuffer(), sizeof (shadow_vertex_t) );
m_D3DRender ->SetVertexShader ( GTH_SHADOW_FORMAT_NEO );
m_pd3dDevice ->DrawPrimitive ( D3DPT_TRIANGLELIST, m_shadowVBNeo ->GetBase (), size / 3 );
return;
}
#endif
void FX_CCharManager::ClearDamageBuffer ( Fx_CHARACTER_t *in_char )
{
memset ( in_char ->atk_infoBuffer, 0, sizeof (in_char ->atk_infoBuffer) );
in_char ->atk_nextStartFrame = -1;
in_char ->atk_indexStart = 0;
in_char ->atk_nextBeginFrame = -1;
in_char ->atk_indexBegin = 0;
in_char ->atk_nextDamageFrame = -1;
in_char ->atk_indexDamage = 0;
in_char ->atk_nextFreeFrame = -1;
in_char ->atk_indexFree = 0;
in_char ->atk_changeEvent = false;
in_char ->atk_resend = false;
}
int FX_CCharManager::StartNewComboAttack ( Fx_CHARACTER_t *in_char )
{
ClearDamageBuffer ( in_char );
SetNextBeginFrame ( in_char );
SetNextDamageFrame ( in_char );
SetNextFreeFrame ( in_char );
SetNextStartFrame ( in_char );
return true;
}
int FX_CCharManager::SetNextBeginFrame ( Fx_CHARACTER_t *in_char )
{
if ( in_char ->atk_indexBegin >= m_pAnimManager ->GetComboCount ( in_char ->ani_curIdx ) )
{
in_char ->atk_nextBeginFrame = -1;
in_char ->atk_indexBegin = 0;
}
else
{
in_char ->atk_nextBeginFrame = m_pAnimManager ->GetDamageFrame ( in_char ->ani_curIdx, in_char ->atk_indexBegin ) - COMBO_DAMAGE_REQUEST_FRAME_OFFSET;
if ( in_char ->atk_nextBeginFrame < 0 )
in_char ->atk_nextBeginFrame = 0;
++in_char ->atk_indexBegin;
}
return true;
}
int FX_CCharManager::SetNextDamageFrame ( Fx_CHARACTER_t *in_char )
{
if ( in_char ->atk_indexDamage >= m_pAnimManager ->GetComboCount ( in_char ->ani_curIdx ) )
{
in_char ->atk_nextDamageFrame = -1;
in_char ->atk_indexDamage = 0;
}
else
{
in_char ->atk_nextDamageFrame = m_pAnimManager ->GetDamageFrame ( in_char ->ani_curIdx, in_char ->atk_indexDamage );
if ( in_char ->atk_nextDamageFrame < 0 )
in_char ->atk_nextDamageFrame = 0;
++in_char ->atk_indexDamage;
}
return true;
}
int FX_CCharManager::SetNextFreeFrame ( Fx_CHARACTER_t *in_char )
{
if ( in_char ->atk_indexFree >= m_pAnimManager ->GetComboCount ( in_char ->ani_curIdx ) )
{
in_char ->atk_nextFreeFrame = -1;
in_char ->atk_indexFree = 0;
}
else
{
in_char ->atk_nextFreeFrame = m_pAnimManager ->GetFreeFrame ( in_char ->ani_curIdx, in_char ->atk_indexFree );
if ( in_char ->atk_nextFreeFrame < 0 )
in_char ->atk_nextFreeFrame = 0;
++in_char ->atk_indexFree;
}
return true;
}
int FX_CCharManager::GotDamageMessage ( int in_defenderIdx,
int in_defenderType,
int in_attackerIdx,
int in_attackerType,
int in_damage,
int in_stun )
{
Fx_CHARACTER_t *attacker;
if( in_damage < 0 ) {
in_damage = 0;
in_stun = 0;
}
attacker = FindCharacterByServerIndex ( in_attackerIdx, in_attackerType );
if ( attacker == NULL )
return false;
int thisEntryIndex = FindDamageBufferEntry ( attacker, false );
if ( thisEntryIndex < 0 )
{
return false;
}
ATTACKINFO_t& atkInfo = attacker ->atk_infoBuffer [thisEntryIndex];
if ( atkInfo.expired )
{
g_ifMng ->m_numCtl ->AddDamageNumber ( in_defenderIdx, in_defenderType, in_attackerIdx, in_attackerType, in_damage, in_stun );
g_ifMng ->m_numCtl ->ReadyDamage ( attacker );
DeleteDamageBufferEntry ( attacker, thisEntryIndex );
}
else
{
atkInfo.used = true;
atkInfo.attackerIdx = (WORD)in_attackerIdx;
atkInfo.attackerType = (WORD)in_attackerType;
atkInfo.defenderIdx = (WORD)in_defenderIdx;
atkInfo.defenderType = (WORD)in_defenderType;
atkInfo.damage = (WORD)in_damage;
atkInfo.stun = (WORD)in_stun;
atkInfo.identifier = g_pApp ->m_frameFlag;
}
return true;
}
int FX_CCharManager::FindDamageBufferEntry ( Fx_CHARACTER_t *in_char,
bool in_used )
{
int index;
for ( index = 0; \
index < MAX_COUNT_ATTACK_INFOS; \
++index )
{
if ( in_used == in_char ->atk_infoBuffer [index].used )
return index;
}
return -1;
}
int FX_CCharManager::DeleteDamageBufferEntry ( Fx_CHARACTER_t *in_char,
int in_index )
{
assert ( in_index >= 0 );
assert ( in_index < MAX_COUNT_ATTACK_INFOS );
if ( in_index < ( MAX_COUNT_ATTACK_INFOS - 1 ) )
{
memcpy ( &in_char ->atk_infoBuffer [in_index], &in_char ->atk_infoBuffer [in_index + 1], sizeof(ATTACKINFO_t) * ( MAX_COUNT_ATTACK_INFOS - in_index - 1 ) );
}
memset ( &in_char ->atk_infoBuffer [MAX_COUNT_ATTACK_INFOS - 1], 0, sizeof(ATTACKINFO_t) );
return true;
}
int FX_CCharManager::ProcessDamageFrame ( Fx_CHARACTER_t *in_char )
{
int usedEntry = FindDamageBufferEntry ( in_char, true );
if ( usedEntry < 0 )
{
int index;
for ( index = 0; \
index < MAX_COUNT_ATTACK_INFOS; \
++index )
{
if ( ! in_char ->atk_infoBuffer [index].expired )
{
in_char ->atk_infoBuffer [index].expired = true;
break;
}
}
return false;
}
else
{
ShowDamage ( in_char, usedEntry );
}
return true;
}
int FX_CCharManager::SetNextStartFrame ( Fx_CHARACTER_t *in_char )
{
if ( in_char ->atk_indexStart >= m_pAnimManager ->GetComboCount ( in_char ->ani_curIdx ) )
{
in_char ->atk_nextStartFrame = -1;
in_char ->atk_indexStart = 0;
}
else
{
in_char ->atk_nextStartFrame = m_pAnimManager ->GetStartFrame ( in_char ->ani_curIdx, in_char ->atk_indexStart );
if ( in_char ->atk_nextStartFrame < 0 )
in_char ->atk_nextStartFrame = 0;
++in_char ->atk_indexStart;
}
return true;
}
void FX_CCharManager::ShowAttackEffect ( Fx_CHARACTER_t *in_attacker , int damage )
{
int targetID;
targetID = g_GameTarget.GTH_GetTargetClientID( in_attacker );
if( targetID < 0 ) return;
Fx_CHARACTER_t *defender = &m_Characters [targetID];
vec3_t targetPos;
vec3_t targetAngle;
vec3_t targetOrigin;
float height;
VectorSubtract ( targetPos, in_attacker ->position, defender ->position );
VectorToAngles ( targetPos, targetAngle );
VectorCopy ( targetOrigin, defender ->position );
if ( defender ->stat_height > in_attacker ->stat_height )
{
height = in_attacker ->stat_height;
}
else
{
height = defender ->stat_height;
}
targetOrigin [2] += height;
targetOrigin [2] += ( rand () / (float)RAND_MAX ) * height * 0.5f;
float random = rand () / (float)RAND_MAX;
if ( random < 0.3f )
{
g_effectMng ->Add ( GTH_EFFECT_CLASS_MODEL, 0, targetOrigin, NULL, targetAngle );
}
else if ( random < 0.6f )
{
g_effectMng ->Add ( GTH_EFFECT_CLASS_MODEL, 1, targetOrigin, NULL, targetAngle );
}
else
{
g_effectMng ->Add ( GTH_EFFECT_CLASS_MODEL, 2, targetOrigin, NULL, targetAngle );
}
if ( ( rand() / (float)RAND_MAX ) < 1.0f )
SetCharTrembling ( targetID, 0.1f, 0.5f );
if( damage > 0 )
g_soundMng ->PlayDamageSound ( defender );
}
Fx_CHARACTER_t* FX_CCharManager::FindCharacterByServerIndex ( int in_serverIdx,
int in_type )
{
for ( int index = 0; \
index < MAX_CHAR_A_SCENE; \
++index )
{
if ( ( m_Characters [index].idxOnServer == in_serverIdx ) &&
( m_Characters [index].entityType == in_type ) )
return &m_Characters [index];
}
return NULL;
}
int FX_CCharManager::ShowDamage ( Fx_CHARACTER_t *in_char,
int in_entryIdx )
{
ATTACKINFO_t *atkInfo;
atkInfo = &in_char ->atk_infoBuffer [in_entryIdx];
g_ifMng ->m_numCtl ->AddDamageNumber ( atkInfo ->defenderIdx, atkInfo ->defenderType, atkInfo ->attackerIdx, atkInfo ->attackerType, atkInfo ->damage, atkInfo ->stun );
g_ifMng ->m_numCtl ->ReadyDamage ( in_char );
DWORD identifier = atkInfo ->identifier;
DeleteDamageBufferEntry ( in_char, in_entryIdx );
while ( ( in_entryIdx = FindDamageBufferEntry ( in_char, true ) ) >= 0 )
{
atkInfo = &in_char ->atk_infoBuffer [in_entryIdx];
if ( atkInfo ->identifier == identifier )
{
g_ifMng ->m_numCtl ->AddDamageNumber ( atkInfo ->defenderIdx, atkInfo ->defenderType, atkInfo ->attackerIdx, atkInfo ->attackerType, atkInfo ->damage, atkInfo ->stun );
g_ifMng ->m_numCtl ->ReadyDamage ( in_char );
DeleteDamageBufferEntry ( in_char, in_entryIdx );
}
else
break;
}
return true;
}
float FX_CCharManager::CalcAttackLength ( Fx_CHARACTER_t *in_char )
{
int itemTableIdx = in_char ->equipment [0];
int classIdx = g_itemTable [itemTableIdx].classIdx;
if ( g_itemClassTable [classIdx].attackAtt )
return g_itemTable [itemTableIdx].atkLength;
else
return -1.0f;
}
void FX_CCharManager::SetCharTrembling ( const int in_charIdx,
const float in_duration,
const float in_power )
{
Fx_CHARACTER_t *thisChar = &m_Characters [in_charIdx];
thisChar ->tb_duration = in_duration;
thisChar ->tb_power = in_power;
thisChar ->tb_startTime = g_timer .GetAppTime ();
thisChar ->tb_do = true;
VectorCopy ( thisChar ->tb_originalPos, thisChar ->position );
return;
}
void FX_CCharManager::StopCharTrembling ( const int in_charIdx )
{
Fx_CHARACTER_t *thisChar = &m_Characters [in_charIdx];
if ( ! thisChar ->tb_do ) return;
thisChar ->tb_do = false;
VectorCopy ( thisChar ->position, thisChar ->tb_originalPos );
return;
}
void FX_CCharManager::CheckCharTrembling ()
{
Fx_CHARACTER_t *thisChar = &m_Characters [0];
for ( int index = 0; \
index < MAX_CHAR_A_SCENE; \
++index, ++thisChar )
{
if ( thisChar ->tb_do )
{
if ( ( g_timer .GetAppTime () - thisChar ->tb_startTime ) > thisChar ->tb_duration )
{
StopCharTrembling ( index );
}
}
}
return;
}
| C++ |
#ifndef _NON_SKINNING_MESH_MANAGER_H_J09D3J09JD
#define _NON_SKINNING_MESH_MANAGER_H_J09D3J09JD
typedef struct
{
FX_CMesh mesh;
UINT iRefID;
UINT iVertexStart;
UINT iNumVertex;
UINT iIndexStart;
UINT iPrimitiveCount;
int iTagIndex;
int iParentTagIndex;
} ITEM_t;
class FX_CItemManager
{
public:
FX_CItemManager();
~FX_CItemManager();
public:
ITEM_t m_Items [MAX_COUNT_ITEM_MESH];
int m_iNumItems;
Fx_ITEM_BUF_t m_ItemBuffer [MAX_COUNT_ITEM_MESH];
CHAR_BUFFER_t m_CharBuffer [MAX_COUNT_AVAIL_ITEM];
int m_iNumMeshInBuffer;
int m_iBufferIndexMap [MAX_COUNT_ITEM_MESH];
FX_CItemRenderer *m_pItemRenderer;
FX_CCharManager *m_pCharManager;
FX_CSkinManager *m_pSkinManager;
FX_CSkelManager *m_pSkelManager;
FX_CCharUtil *m_pCharUtil;
FX_CCharShaderMng *m_pCharShaderMng;
CTagManager *m_pTagManager;
FX_CBoneManager *m_pBoneManager;
CScript *m_pScript;
CD3DTextureMng *m_texMng;
CFileMng *m_fileMng;
CD3DRender *m_D3DRender;
CShaderMng *m_shaderMng;
CTimer *m_timer;
LPDIRECT3DDEVICE8 m_pd3dDevice;
public:
bool LoadItemList();
void UpdateTextureID();
bool CountVertices ( UINT &iVertexResult, UINT &iIndexResult );
void PrepareRenderBuffers ();
void ReleaseRenderBuffers ();
bool UpdateCharBuffer();
bool RenderAll ( int *in_numprims );
void Render ( Fx_CHARACTER_t *in_char, const int in_refIdx, const ITEM_t *pThisItem );
void EffectRender ( Fx_CHARACTER_t *in_char, const int in_refIdx, const ITEM_t *pThisItem );
void Cleanup();
void SetCharManager ( FX_CCharManager *charManager ) { m_pCharManager = charManager; }
void SetSkinManager ( FX_CSkinManager *skinManager ) { m_pSkinManager = skinManager; }
void SetSkelManager ( FX_CSkelManager *skelManager ) { m_pSkelManager = skelManager; }
void SetCharUtil ( FX_CCharUtil *charUtil ) { m_pCharUtil = charUtil; }
void SetTagManager ( CTagManager *tagManager ) { m_pTagManager = tagManager; }
void SetBoneManager ( FX_CBoneManager *boneManager ) { m_pBoneManager = boneManager; }
void SetScript ( CScript *script ) { m_pScript = script; }
void SetDevice ( LPDIRECT3DDEVICE8 device );
void SetTexManager ( CD3DTextureMng *texMng );
void SetFileManager ( CFileMng *fileMng ) { m_fileMng = fileMng; }
void SetRenderer ( CD3DRender *d3dRender );
void SetShaderMng ( CShaderMng *shaderMng );
void SetCharShaderMng ( FX_CCharShaderMng *charShaderMng ) { m_pCharShaderMng = charShaderMng; };
matrix4x4_t* GetTagMatrixOut ( Fx_CHARACTER_t *in_char, const int in_tag );
matrix4x4_t* GetTagMatrix ( Fx_CHARACTER_t *in_char, const int in_tag, const int in_parentTag );
void GetTagMatrixUntransformed ( Fx_CHARACTER_t *in_char, const int in_tag, const int in_parentTag, matrix4x4_t &out_matrix );
void MakeTagMatrix ( const Fx_CHARACTER_t *in_char, const KEYFRAME *in_frame, const TAG *in_tag, const int in_tagID,
matrix4x4_t &out_matrix, const bool in_transform );
void SetTimer ( CTimer *timer ) { m_timer = timer; }
void GetCharPosByIdxOnSvr ( const int in_targetIdx, vec3_t out_pos );
void TagLookTarget ( const vec3_t in_mypos, const int in_tgtIdx, vec4_t out_quat );
void TagLookCenter ( const vec3_t in_direction, vec4_t out_quat );
private:
bool LoadItem ( char *pszSkinName, const unsigned int iSkinID, const unsigned int iTexID );
};
#endif | C++ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.