void CThirdPersonCamera::Update(float fTimeElapsed)
{
//플레이어의 회전에 따라 3인칭 카메라도 회전해야 한다.
if (m_pPlayer)
{
D3DXMATRIX mtxRotate;
D3DXMatrixIdentity(&mtxRotate);
D3DXVECTOR3 d3dxvRight = m_pPlayer->GetRightVector();
D3DXVECTOR3 d3dxvUp = m_pPlayer->GetUpVector();
D3DXVECTOR3 d3dxvLook = m_pPlayer->GetLookVector();
//플레이어의 로컬 x-축, y-축, z-축 벡터로부터 회전 행렬을 생성한다.
mtxRotate._11 = d3dxvRight.x; mtxRotate._21 = d3dxvUp.x; mtxRotate._31 = d3dxvLook.x;
mtxRotate._12 = d3dxvRight.y; mtxRotate._22 = d3dxvUp.y; mtxRotate._32 = d3dxvLook.y;
mtxRotate._13 = d3dxvRight.z; mtxRotate._23 = d3dxvUp.z; mtxRotate._33 = d3dxvLook.z;
D3DXVECTOR3 d3dxvOffset;
D3DXVec3TransformCoord(&d3dxvOffset, &m_d3dxvOffset, &mtxRotate);
//회전한 카메라의 위치는 플레이어의 위치에 회전한 카메라 오프셋 벡터를 더한 것이다.
D3DXVECTOR3 d3dxvPosition = m_pPlayer->GetPosition() + d3dxvOffset;
//현재의 카메라의 위치에서 회전한 카메라의 위치까지의 벡터이다.
D3DXVECTOR3 d3dxvDirection = d3dxvPosition - m_d3dxvPosition;
float fLength = D3DXVec3Length(&d3dxvDirection);
D3DXVec3Normalize(&d3dxvDirection, &d3dxvDirection);
//3인칭 카메라의 래그(Lag)는 플레이어가 회전하더라도 카메라가 동시에 따라서 회전하지 않고 약간의 시차를 두고 회전하는 효과를 구현하기 위한 것이다. m_fTimeLag가 1보다 크면 fTimeLagScale이 작아지고 실제 회전이 적게 일어날 것이다.*/
float fTimeLagScale = (m_fTimeLag) ? fTimeElapsed * (1.0f / m_fTimeLag) : 1.0f;
float fDistance = fLength * fTimeLagScale;
if (fDistance > fLength) fDistance = fLength;
if (fLength < 0.01f) fDistance = fLength;
if (fDistance > 0)
{
m_d3dxvPosition += d3dxvDirection * fDistance;
SetLookAt(GetLookAtPosition());
}
}
}
void CCSBot::Panic(CBasePlayer *pEnemy)
{
if (IsSurprised())
return;
Vector2D dir(BotCOS(pev->v_angle.y), BotSIN(pev->v_angle.y));
Vector2D perp(-dir.y, dir.x);
Vector spot;
if (GetProfile()->GetSkill() >= 0.5f)
{
Vector2D toEnemy = (pEnemy->pev->origin - pev->origin).Make2D();
toEnemy.NormalizeInPlace();
float along = DotProduct(toEnemy, dir);
float c45 = 0.7071f;
float size = 100.0f;
real_t shift = RANDOM_FLOAT(-75.0, 75.0);
if (along > c45)
{
spot.x = pev->origin.x + dir.x * size + perp.x * shift;
spot.y = pev->origin.y + dir.y * size + perp.y * shift;
}
else if (along < -c45)
{
spot.x = pev->origin.x - dir.x * size + perp.x * shift;
spot.y = pev->origin.y - dir.y * size + perp.y * shift;
}
else if (DotProduct(toEnemy, perp) > 0.0)
{
spot.x = pev->origin.x + perp.x * size + dir.x * shift;
spot.y = pev->origin.y + perp.y * size + dir.y * shift;
}
else
{
spot.x = pev->origin.x - perp.x * size + dir.x * shift;
spot.y = pev->origin.y - perp.y * size + dir.y * shift;
}
}
else
{
const float offset = 200.0f;
real_t side = RANDOM_FLOAT(-offset, offset) * 2.0f;
spot.x = pev->origin.x - dir.x * offset + perp.x * side;
spot.y = pev->origin.y - dir.y * offset + perp.y * side;
}
spot.z = pev->origin.z + RANDOM_FLOAT(-50.0, 50.0);
// we are stunned for a moment
m_surpriseDelay = RANDOM_FLOAT(0.1, 0.2);
m_surpriseTimestamp = gpGlobals->time;
SetLookAt("Panic", &spot, PRIORITY_HIGH, 0, 0, 5.0);
PrintIfWatched("Aaaah!\n");
}
/*!
*
* @param lookAtVec
* @param upVec
*/
Camera::Camera(glm::vec3 positionVec, glm::vec3 lookAtVec, glm::vec3 upVec)
{
m_initPos = positionVec;
m_position = positionVec;
m_initLookAt = lookAtVec;
m_lookAt = lookAtVec;
m_initUp = upVec;
m_up = upVec;
m_lookVec = m_initLookAt - m_initPos;
m_initSide = glm::cross(m_lookVec, m_initUp);
m_side = glm::cross(m_lookVec, m_initUp);
SetSide(m_side);
SetUp(m_up);
SetLookAt(m_lookAt);
SetPosition(m_position);
m_fieldOfView = 60.0f;
m_width = Singleton<Context>::Instance()->GetWidth();
m_height = Singleton<Context>::Instance()->GetHeight();
m_aspect = static_cast<float>(m_width) / static_cast<float>(m_height);
m_nearPlane = 0.1f;
m_farPlane = 200.f;
m_viewMatrix = glm::lookAt(m_position, m_lookAt, m_up);
m_inverseViewMatrix = glm::inverse(m_viewMatrix);
m_projectionMatrix = glm::perspective(m_fieldOfView, m_aspect, m_nearPlane, m_farPlane);
m_isOrtho = false;
m_speed = 0.05;
}
/*!
*
*/
Camera::Camera()
{
m_position = glm::vec3(0.0, 0.0, 1.0);
m_lookAt = glm::vec3(0.0, 0.0, 0.0);
m_up = glm::vec3(0.0, 1.0, 0.0);
m_side = glm::vec3(1.0, 0.0, 0.0);
SetSide(m_side);
SetUp(m_up);
SetLookAt(m_lookAt);
SetPosition(m_position);
m_fieldOfView = 60.0f;
m_width = Singleton<Context>::Instance()->GetWidth();
m_height = Singleton<Context>::Instance()->GetHeight();
m_aspect = static_cast<float>(m_width) / static_cast<float>(m_height);
m_nearPlane = 0.1f;
m_farPlane = 200.0f;
m_viewMatrix = glm::lookAt(m_position, m_lookAt, m_up);
m_inverseViewMatrix = glm::inverse(m_viewMatrix);
m_projectionMatrix = glm::perspective(m_fieldOfView, m_aspect, m_nearPlane, m_farPlane);
m_isOrtho = false;
m_speed = 0.05;
}
cCamera::cCamera()
: m_vEyePt(0, 3, -30)
, m_vLookAt(0, 0, 0)
, m_vUpVec(0, 1, 0)
{
if(m_Number == 0)
{
CurrCamera = 0;
}
m_Number = Number;
Number++;
#ifdef DIMENSION_3D // 3D
#ifndef VIEW_3D // 쿼터뷰
SetEyePt(-8.f, 8.f, -8.f);
SetLookAt(0.f, 0.f, 0.f);
#endif
#else // 2D
SetEyePt(0.f, 0.f, -8.f);
SetLookAt(0.f, 0.f, 0.f);
#endif
}
CCamera_Scene::CCamera_Scene(Ogre::Camera* pOgreCamera, const fVector3& fvPos, FLOAT fAddHeight, FLOAT fPitch, FLOAT fDistance, FLOAT fDirection)
: CCamera(pOgreCamera)
{
//-----------------------------------------------
// 进行初始化设置
SetLookAt(fvPos);
SetAddHeight(fAddHeight);
SetPitch(fPitch);
SetApprochPitch( fPitch );
SetDistance(fDistance);
SetDirection(fDirection);
m_status = NORMAL_STATUS;
m_fOffset = 0.0f;
Fairy::EffectManager::getSingleton().setEffectCameraShakeCallback(&s_EffectCameraShakeCallback);
}
int main( int argc, char *argv[] )
{
GLFWwindow *window;
int Edit;
//File name to load
string fileName;
//whether name inputtted is valid
bool validFile = false;
//Try to determine file input
while(validFile == false) {
printf("Type the file to load (Special options: 'd' = default, 'c' = clean):\n");
scanf("%s", &fileName[0]);
ifstream toLoad(&fileName[0]);
validFile = toLoad.good();
//If 'c' was entered, then load a clean level
if(strcmp(&fileName[0], "c") == 0) {
printf("Loading clean level...\n");
fileName = "clean";
validFile = true;
}
//If 'd' was entered, then deafult level
else if(strcmp(&fileName[0], "d") == 0) {
printf("Loading default level...\n");
fileName = "default";
validFile = true;
}
else if(validFile == false) {
printf("Bad file, please type another file to load.\n");
}
else if(validFile == true) {
toLoad.close();
}
}
//Determine mode
printf("Type 0 to play, any other int to edit\n");
scanf("%i", &Edit);
glfwSetErrorCallback(glfwError);
if (!glfwInit()) {
exit(EXIT_FAILURE);
}
//If Edit Mode
if(Edit) {
//World Edit Init
//initWorldEdit(window);
window = glfwCreateWindow(800, 800, "World Editor", NULL, NULL);
if (!window) {
glfwTerminate();
exit(EXIT_FAILURE);
}
srand(time(0));
glfwMakeContextCurrent(window);
glfwSetWindowPos(window, 80, 80);
glfwSetWindowSizeCallback(window, glfwWindowResize);
glfwSetWindowSize(window,1600,800);
g_height =800;
g_width = 1600;
setDistance(7);
SetEdit(1);
paused = false;
glfwSetKeyCallback( window, glfwEditKeyPress);
glfwSetCursorPosCallback( window, glfwEditGetCursorPos );
glfwSetMouseButtonCallback( window, glfwEditMouse );
glfwSetScrollCallback( window, glfwEditScroll );
glewInit();
glInitialize(window);
physicsInit();
InitGeom();
initLevelLoader();
loadLevel(fileName);
}
//If Play Mode
else {
//Game Play Init
//initGamePlay(window);
window = glfwCreateWindow(800, 800, "Grapple", NULL, NULL);
if (!window) {
glfwTerminate();
exit(EXIT_FAILURE);
}
srand(time(0));
SetEye(vec3(0, 0, 0));
glfwMakeContextCurrent(window);
glfwSetWindowPos(window, 80, 80);
glfwSetWindowSizeCallback(window, glfwWindowResize);
glfwSetWindowSize(window,1600,800);
g_height =800;
g_width = 1600;
setDistance(10);
paused = false;
glfwSetKeyCallback(window, glfwGameKeyPress);
glfwSetCursorPosCallback( window, glfwGameGetCursorPos );
glewInit();
glInitialize(window);
physicsInit();
InitGeom();
initLevelLoader();
loadLevel(fileName);
}
ShadowMap *shadowMap = new ShadowMap();
if (shadowMap->MakeShadowMap(g_width, g_height) == -1) {
printf("SHADOW MAP FAILED\n");
exit(EXIT_FAILURE);
}
// Start the main execution loop.
while (!glfwWindowShouldClose(window)) {
glfwPollEvents();
if(Edit) {
if(paused == false) {
//Keep the cursor centered
glfwSetCursorPos(window,g_width/2,g_height/2);
renderScene(window, shadowMap);
glfwEditGetCursorPos(NULL,g_width/2.0,g_height/2.0);
//glfw Game Keyboard
glfwEditKeyboard();
}
}
else {
if(paused == false) {
//player appy physics controls
SetLookAt(glm::vec3(physGetPlayerX(),physGetPlayerY(),physGetPlayerZ()));
SetSpeed(.05*magnitude(getPlayerSpeed()));
//Keep the cursor centered
glfwSetCursorPos(window,g_width/2,g_height/2);
physStep();
//Draw stuff
renderScene(window, shadowMap);
glfwGameGetCursorPos(NULL,g_width/2.0,g_height/2.0);
//glfw Game Keyboard
glfwGameKeyboard();
}
}
usleep(15000);
}
// Clean up after GLFW.
glfwDestroyWindow(window);
glfwTerminate();
exit(EXIT_SUCCESS);
}
void cCamera::SetLookAt(const float & _x, const float & _y, const float & _z)
{
SetLookAt(D3DXVECTOR3(_x, _y, _z));
}
void Camera::SetLookAtStandardPosition(void)
{
SetLookAt(0.0, 0.0, 1.0,
0.0, 0.0, 0.0,
0.0, 1.0, 0.0);
}
// Update the "looking around" behavior.
void CCSBot::UpdateLookAround(bool updateNow)
{
// check if looking around has been inhibited
// Moved inhibit to allow high priority enemy lookats to still occur
if (gpGlobals->time < m_inhibitLookAroundTimestamp)
return;
const float recentThreatTime = 0.25f; // 1.0f;
// Unless we can hear them moving, in which case look towards the noise
if (!IsEnemyVisible())
{
const float noiseStartleRange = 1000.0f;
if (CanHearNearbyEnemyGunfire(noiseStartleRange))
{
Vector spot = m_noisePosition;
spot.z += HalfHumanHeight;
SetLookAt("Check dangerous noise", &spot, PRIORITY_HIGH, recentThreatTime);
InhibitLookAround(RANDOM_FLOAT(2.0f, 4.0f));
return;
}
}
// If we recently saw an enemy, look towards where we last saw them
if (!IsLookingAtSpot(PRIORITY_MEDIUM) && gpGlobals->time - m_lastSawEnemyTimestamp < recentThreatTime)
{
ClearLookAt();
Vector spot = m_lastEnemyPosition;
// find enemy position on the ground
if (GetSimpleGroundHeight(&m_lastEnemyPosition, &spot.z))
{
spot.z += HalfHumanHeight;
SetLookAt("Last Enemy Position", &spot, PRIORITY_MEDIUM, RANDOM_FLOAT(2.0f, 3.0f), true);
return;
}
}
// Look at nearby enemy noises
if (UpdateLookAtNoise())
return;
if (IsNotMoving())
{
// if we're sniping, zoom in to watch our approach points
if (IsUsingSniperRifle())
{
// low skill bots don't pre-zoom
if (GetProfile()->GetSkill() > 0.4f)
{
if (!IsViewMoving())
{
float range = ComputeWeaponSightRange();
AdjustZoom(range);
}
else
{
// zoom out
if (GetZoomLevel() != NO_ZOOM)
SecondaryAttack();
}
}
}
if (m_lastKnownArea == NULL)
return;
if (gpGlobals->time < m_lookAroundStateTimestamp)
return;
// if we're sniping, switch look-at spots less often
if (IsUsingSniperRifle())
m_lookAroundStateTimestamp = gpGlobals->time + RANDOM_FLOAT(5.0f, 10.0f);
else
m_lookAroundStateTimestamp = gpGlobals->time + RANDOM_FLOAT(1.0f, 2.0f);
if (m_approachPointCount == 0)
{
ClearLookAt();
return;
}
int which = RANDOM_LONG(0, m_approachPointCount - 1);
Vector spot = m_approachPoint[ which ];
// don't look at the floor, look roughly at chest level
// TODO: If this approach point is very near, this will cause us to aim up in the air if were crouching
spot.z += HalfHumanHeight;
SetLookAt("Approach Point (Hiding)", &spot, PRIORITY_LOW);
return;
}
// Glance at "encouter spots" as we move past them
if (m_spotEncounter)
{
// Check encounter spots
if (!IsSafe() && !IsLookingAtSpot(PRIORITY_LOW))
{
// allow a short time to look where we're going
if (gpGlobals->time < m_spotCheckTimestamp)
return;
// TODO: Use skill parameter instead of accuracy
// lower skills have exponentially longer delays
float_precision asleep = (1.0f - GetProfile()->GetSkill());
asleep *= asleep;
asleep *= asleep;
m_spotCheckTimestamp = gpGlobals->time + asleep * RANDOM_FLOAT(10.0f, 30.0f);
// figure out how far along the path segment we are
Vector delta = m_spotEncounter->path.to - m_spotEncounter->path.from;
float_precision length = delta.Length();
float adx = float(Q_abs(int64(delta.x)));
float ady = float(Q_abs(int64(delta.y)));
float_precision t;
if (adx > ady)
t = (pev->origin.x - m_spotEncounter->path.from.x) / delta.x;
else
t = (pev->origin.y - m_spotEncounter->path.from.y) / delta.y;
// advance parameter a bit so we "lead" our checks
const float leadCheckRange = 50.0f;
t += leadCheckRange / length;
if (t < 0.0f)
t = 0.0f;
else if (t > 1.0f)
t = 1.0f;
// collect the unchecked spots so far
const int MAX_DANGER_SPOTS = 8;
HidingSpot *dangerSpot[MAX_DANGER_SPOTS];
int dangerSpotCount = 0;
int dangerIndex = 0;
const float checkTime = 10.0f;
const SpotOrder *spotOrder;
for (SpotOrderList::iterator iter = m_spotEncounter->spotList.begin(); iter != m_spotEncounter->spotList.end(); ++iter)
{
spotOrder = &(*iter);
// if we have seen this spot recently, we don't need to look at it
if (gpGlobals->time - GetHidingSpotCheckTimestamp(spotOrder->spot) <= checkTime)
continue;
if (spotOrder->t > t)
break;
dangerSpot[ dangerIndex++ ] = spotOrder->spot;
if (dangerIndex >= MAX_DANGER_SPOTS)
dangerIndex = 0;
if (dangerSpotCount < MAX_DANGER_SPOTS)
++dangerSpotCount;
}
if (dangerSpotCount)
{
// pick one of the spots at random
int which = RANDOM_LONG(0, dangerSpotCount - 1);
const Vector *checkSpot = dangerSpot[ which ]->GetPosition();
Vector pos = *checkSpot;
pos.z += HalfHumanHeight;
// glance at the spot for minimum time
SetLookAt("Encounter Spot", &pos, PRIORITY_LOW, 0, true, 10.0f);
// immediately mark it as "checked", so we don't check it again
// if we get distracted before we check it - that's the way it goes
SetHidingSpotCheckTimestamp(dangerSpot[which]);
}
}
}
}
void Camera2D::Update()
{
SetLookAt( gUnitPlayer().GetPos() );
}
// When bot is touched by another entity.
void CCSBot::BotTouch(CBaseEntity *pOther)
{
// if we have touched a higher-priority player, make way
// TODO: Need to account for reaction time, etc.
if (pOther->IsPlayer())
{
// if we are defusing a bomb, don't move
if (IsDefusingBomb())
return;
CBasePlayer *pPlayer = static_cast<CBasePlayer *>(pOther);
// get priority of other player
unsigned int otherPri = TheCSBots()->GetPlayerPriority(pPlayer);
// get our priority
unsigned int myPri = TheCSBots()->GetPlayerPriority(this);
// if our priority is better, don't budge
if (myPri < otherPri)
return;
// they are higher priority - make way, unless we're already making way for someone more important
if (m_avoid)
{
unsigned int avoidPri = TheCSBots()->GetPlayerPriority(m_avoid);
if (avoidPri < otherPri)
{
// ignore 'pOther' because we're already avoiding someone better
return;
}
}
m_avoid = static_cast<CBasePlayer *>(pOther);
m_avoidTimestamp = gpGlobals->time;
return;
}
// If we won't be able to break it, don't try
if (pOther->pev->takedamage != DAMAGE_YES)
return;
if (IsAttacking())
return;
// See if it's breakable
if (FClassnameIs(pOther->pev, "func_breakable"))
{
Vector center = (pOther->pev->absmax + pOther->pev->absmin) / 2.0f;
bool breakIt = true;
if (m_pathLength)
{
Vector goal = m_goalPosition + Vector(0, 0, HalfHumanHeight);
breakIt = IsIntersectingBox(pev->origin, goal, pOther->pev->absmin, pOther->pev->absmax);
}
if (breakIt)
{
// it's breakable - try to shoot it.
SetLookAt("Breakable", ¢er, PRIORITY_HIGH, 0.2, 0, 5.0);
if (IsUsingGrenade())
{
EquipBestWeapon();
return;
}
PrimaryAttack();
}
}
}