void CEditDirctionLine::Render() const
{
if( m_vEnd.x == m_vStart.x )
return;
size_t PointNum = 2 + m_nWeight * 4 + 4;
VerColor3D* pVB;
RenderState* pRS;
CMatrix* pMatrix = CGraphic::GetInst()->GetRenderStack( RS_DEFAULT, NULL, NULL, PT_LINELIST,
PointNum, PointNum/2, VerColor3D::Format, sizeof(VerColor3D),
(void**)&pVB, NULL, (void**)&pRS );
pRS->m_LightEnable = FALSE;
pMatrix->Identity();
pVB[0].p = m_vStart;
pVB[1].p = m_vEnd;
pVB[0].diffuse = pVB[1].diffuse = m_dwColor;
int startIndex = 0;
for ( int m = 1; m <= m_nWeight; ++m )
{
CVector3f temp = CVector3f(0.0f, 0.0f, m * fStep);
pVB[startIndex].p = m_vStart + temp;
pVB[startIndex].diffuse = m_dwColor;
++startIndex;
pVB[startIndex].p = m_vEnd + temp;
pVB[startIndex].diffuse = m_dwColor;
++startIndex;
temp = CVector3f(0.0f, 0.0f, -m * fStep);
pVB[startIndex].p = m_vStart + temp;
pVB[startIndex].diffuse = m_dwColor;
++startIndex;
pVB[startIndex].p = m_vEnd + temp;
pVB[startIndex].diffuse = m_dwColor;
++startIndex;
}
pVB[startIndex].p = m_vStart;
pVB[startIndex+1].p = m_vEnd;
pVB[startIndex].diffuse = pVB[startIndex+1].diffuse = m_dwColor;
pVB[startIndex+2].p = m_vEnd;
pVB[startIndex+2].diffuse = m_dwColor;
pVB[startIndex+3].p = m_vEnd + CVector3f(-8.0f, 5.0f, 2.0f);
pVB[startIndex+3].diffuse = m_dwColor;
pVB[startIndex+4].p = m_vEnd;
pVB[startIndex+4].diffuse = m_dwColor;
pVB[startIndex+5].p = m_vEnd + CVector3f(-8.0f, -5.0f, 2.0f);
pVB[startIndex+5].diffuse = m_dwColor;
pMatrix->Identity();
}
//------------------------------------------------------------------------------
CRenderAudio::CRenderAudio(const CRegionAI& AudioInfo,const SString& AudioName,ILogicHandler* pHandler)
: CRenderNode(pHandler),m_uUnitSetIndex(0)
{
m_pAEmitter = GetAudioModule()->CreateAudioEmitter();
m_pAEmitter->SetAutoStop(true);
m_uUnitSetIndex = AudioInfo.SetIndex;
SetPosition(AudioInfo.cX,AudioInfo.cY,AudioInfo.cZ);
m_bPlayNotRepeat = AudioInfo.bPlayNotRepeat;
m_uPlayTimeLenMin = AudioInfo.uPlayTimeLenMin;
m_uPlayTimeLenMax = AudioInfo.uPlayTimeLenMax;
m_uPlayIntervalMin = AudioInfo.uPlayIntervalMin;
m_uPlayIntervalMax = AudioInfo.uPlayIntervalMax;
m_uCurRandomPlayTime = GetRandomValue(m_uPlayTimeLenMin, m_uPlayTimeLenMax);
m_uCurRandomInterval = GetRandomValue(m_uPlayIntervalMin, m_uPlayIntervalMax);
m_strAudioName = AudioName;
CVector3f mMin = CVector3f(-30.0f, 0.0f, -30.0f);
CVector3f mMax = CVector3f( 30.0f, 60.0f, 30.0f);
float fRange = eGridSpan * AudioRange;
mMin = mMin - CVector3f(fRange, fRange, fRange);
mMax = mMax + CVector3f(fRange, fRange, fRange);
m_OrgAABB.setExtents(mMin, mMax);
UpdateBox();
m_pAEmitter->SetPosition(GetPosition());
m_bNeedPlayBegin = true;
m_bNeedIntervalBegin = true;
m_bPlayError = false;
}
void SetupLights(void)
{
g_p_LightManager = new CLightManager();
g_p_LightManager->setMaxLights(::g_ShaderUniformVariables.MAXLIGHTS);
g_p_LightManager->CreateBasicOpenGLLights(true);
g_p_LightManager->GetLightPointer(0)->setLightType(CLight::POINT);
g_p_LightManager->GetLightPointer(0)->position = CVector3f(224.0f, 328.0f, 244.0f);
g_p_LightManager->GetLightPointer(0)->bIsEnabled = true;
g_p_LightManager->GetLightPointer(1)->setLightType(CLight::POINT);
g_p_LightManager->GetLightPointer(1)->position = CVector3f(0.0f, 10.0f, 0.0f);
g_p_LightManager->GetLightPointer(1)->ambientColour = CVector3f(0.0f, 0.0f, 1.0f);
g_p_LightManager->GetLightPointer(1)->bIsEnabled = true;
//for (unsigned int i = 0; i < vecLightsInfo.size(); i++)
//{
// g_p_LightManager->GetLightPointer(i)->setLightType(vecLightsInfo[i].type);
// g_p_LightManager->GetLightPointer(i)->position = vecLightsInfo[i].pos;
// g_p_LightManager->GetLightPointer(i)->bIsEnabled = true;
// g_p_LightManager->GetLightPointer(i)->diffuseColour.x = vecLightsInfo[i].col.x;
// g_p_LightManager->GetLightPointer(i)->diffuseColour.y = vecLightsInfo[i].col.y;
// g_p_LightManager->GetLightPointer(i)->diffuseColour.z = vecLightsInfo[i].col.z;
// g_p_LightManager->GetLightPointer(i)->constantAttenuation = vecLightsInfo[i].constAtten;
// g_p_LightManager->GetLightPointer(i)->linearAttenuation = vecLightsInfo[i].linAtten;
// g_p_LightManager->GetLightPointer(i)->quadraticAttenuation = vecLightsInfo[i].quadAtten;
// g_p_LightManager->GetLightPointer(i)->calculateRangeFromAttenuation(vecLightsInfo[i].attenRangeStart, vecLightsInfo[i].attenRangeEnd);
//}
return;
}
void CSquare::SetDepth(float fDepth)
{
m_fSizeInDepth = fDepth;
m_vPos[0] = CVector3f(-m_fSizeInWidth*0.5f, 0.0f, -m_fSizeInDepth*0.5f);
m_vPos[1] = CVector3f(-m_fSizeInWidth*0.5f, 0.0f, m_fSizeInDepth*0.5f);
m_vPos[2] = CVector3f(m_fSizeInWidth*0.5f, 0.0f, -m_fSizeInDepth*0.5f);
m_vPos[3] = CVector3f(m_fSizeInWidth*0.5f, 0.0f, m_fSizeInDepth*0.5f);
}
CtrlState CGUICameraCtrller::_DoCameraCtrl( uint32 uCurTime,CCamera* pCamera, CSceneQuery* pQuery )
{
if ( m_NeedReQuery )
{
if ( m_fWearAlready < m_fWearTime )
{
m_bInMove = true;
float fDeltaTime = float(uCurTime - m_uCurTime) * 0.001f;
m_fWearAlready += fDeltaTime;
m_fWearAlready = m_fWearAlready < m_fWearTime ? m_fWearAlready : m_fWearTime;
float temp_scale, temp_xdis, temp_ydis, temp_zdis;
if (m_bNormal)
{
// 从近景到远景的调整
// 调整X
temp_scale = 1.0f + (GUI_CAM_XSCALE_MAX - 1.0f) * m_fWearAlready / m_fWearTime;
temp_xdis = (m_fCurXDis - m_LookAt.x) * temp_scale + m_LookAt.x;
// 调整Y
temp_scale = 1.0f + (GUI_CAM_YSCALE_MAX - 1.0f) * m_fWearAlready / m_fWearTime;
temp_ydis = (m_fCurYDis - m_LookAt.y) * temp_scale + m_LookAt.y;
// 调整Z
temp_scale = 1.0f + (GUI_CAM_ZSCALE_MAX - 1.0f) * m_fWearAlready / m_fWearTime;
temp_zdis = (m_fCurZDis - m_LookAt.z) * temp_scale + m_LookAt.z;
pCamera->SetPosition( CVector3f( temp_xdis, temp_ydis, temp_zdis ) );
}
else
{
// 从远景到近景
// 调整X
temp_scale = 1.0f + (GUI_CAM_XSCALE_MAX - 1.0f) * m_fWearAlready / m_fWearTime;
temp_xdis = (m_fCurXDis - m_LookAt.x) / temp_scale + m_LookAt.x;
// 调整Y
temp_scale = 1.0f + (GUI_CAM_YSCALE_MAX - 1.0f) * m_fWearAlready / m_fWearTime;
temp_ydis = (m_fCurYDis - m_LookAt.y) / temp_scale + m_LookAt.y;
// 调整Z
temp_scale = 1.0f + (GUI_CAM_ZSCALE_MAX - 1.0f) * m_fWearAlready / m_fWearTime;
temp_zdis = (m_fCurZDis - m_LookAt.z) / temp_scale + m_LookAt.z;
pCamera->SetPosition( CVector3f( temp_xdis, temp_ydis, temp_zdis ) );
}
if ( !(m_fWearAlready < m_fWearTime) )
{
// 完成远近景切换
m_fCurXDis = temp_xdis;
m_fCurYDis = temp_ydis;
m_fCurZDis = temp_zdis;
m_bNormal = !m_bNormal;
m_NeedReQuery = false;
m_fWearAlready = 0.0f;
m_bInMove = false;
}
}
}
return CS_CTRL;
}
void CBouncingBall::CollisionResponse()
{
float convergenceThreshold = 0.5f;
if (m_velocity.Length() > convergenceThreshold)
m_velocity = CVector3f(m_velocity.x, -m_velocity.y * m_coefficientOfRestitution, m_velocity.z);
else {
m_velocity = CVector3f(0, 0, 0);
m_acceleration = CVector3f(0, 0, 0);
m_position = CVector3f(m_position.x, m_radius, m_position.z);
m_isActive = false;
}
}
// place a triangle mesh in the grid
void TXGrid3D::PlaceIntoGrid(TXGeometry *geom)
{
m_min = CVector3f(FLT_MAX, FLT_MAX, FLT_MAX);
m_max = CVector3f(-FLT_MAX, -FLT_MAX, -FLT_MAX);
// compute bounding box
int totalTriangles = 0;
TXTriangle* tp;
CVector3f p;
for(ULONG t=0;t<geom->m_triangles.size();t++)
{
tp = geom->m_triangles[t];
totalTriangles++;
for(int i=0;i<3;i++)
{
p = tp->m_v[i]->m_pos;
m_min.Set(
MIN(m_min.GetX(),p.GetX()),
MIN(m_min.GetY(),p.GetY()),
MIN(m_min.GetZ(),p.GetZ())
);
m_max.Set(MAX(m_max.GetX(),p.GetX()),
MAX(m_max.GetY(),p.GetY()),
MAX(m_max.GetZ(),p.GetZ())
);
}
}
Application().LogMessage(L"Total Triangles : "+(CString)totalTriangles);
// select grid size
int grid_size;
if (totalTriangles <= 10000) grid_size = 10;
else if (totalTriangles <= 40000) grid_size = 15;
else grid_size = 20;
// create grid
CreateGrid(grid_size);
m_xstep = (m_max.GetX() - m_min.GetX()) / m_size;
m_ystep = (m_max.GetY() - m_min.GetY()) / m_size;
m_zstep = (m_max.GetZ() - m_min.GetZ()) / m_size;
for(ULONG t=0;t<geom->m_triangles.size();t++)
{
PlaceTriangle(geom->m_triangles[t]);
}
}
CFlareSpriteProp::CFlareSpriteProp( UINT ID, IEffectClassDesc* pEffectClassDesc )
: CEffectUnitProp( ID, pEffectClassDesc )
{
m_vecRotate = CVector3f( 0, 0, 0 );
m_vecNormal = CVector3f( 0, 0, -1 );
m_fMaxAngle = 0.785f;
m_byMinAlpha = 0x00;
m_byMaxAlpha = 0xff;
m_fMinSize = 0;
m_fMaxSize = 10;
m_eFaceType = SPRF_CAMERA;
m_eBlendModel = SPRB_ADD;
m_eZTest = Z_TESTONLY;
m_bLightEnable = FALSE;
}
bool CCollisionBox::IsColliding(CCollisionBox& other)
{
CVector3f _min(CVector3f(m_position.x - (1 * m_scale.x), m_position.y - (1 * m_scale.y), m_position.z - (1 * m_scale.z)));
CVector3f _max(CVector3f(m_position.x + (1 * m_scale.x), m_position.y + (1 * m_scale.y), m_position.z + (1 * m_scale.z)));
CVector3f oMin(CVector3f(other.GetPosition().x - (1 * other.GetScale().x), other.GetPosition().y - (1 *other.GetScale().y), other.GetPosition().z - (1 * other.GetScale().z)));
CVector3f oMax(CVector3f(other.GetPosition().x + (1 * other.GetScale().x), other.GetPosition().y + (1 *other.GetScale().y), other.GetPosition().z + (1 * other.GetScale().z)));
return(_min.x > oMin.x &&
_min.x < oMax.x &&
_max.y > oMin.y &&
_min.y < oMax.y &&
_max.z > oMin.z &&
_min.z < oMax.z);
}
void SQRChartLineGraph::OnRender()
{
if(GetVisible() == false || Empty())
return;
// 绘制常数计算
CFRect wndRect;
m_phost->GetWndRect(wndRect);
const float height = wndRect.bottom - wndRect.top;
//const float zoomSize = m_phost->m_hWnd->m_pGUI->GetZoomSize();
const PointGroup default_pg = {CVector3f(0.0f, 0.0f, 0.0f), GetColor()};
// 绘制数据准备
UIVector<PointGroup> pgList(Count(), default_pg);
for(size_t i = 0; i < Count(); i++)
{
pgList[i].vPoint.x = (wndRect.left + i * m_spanX + m_deltaX);// * zoomSize;
pgList[i].vPoint.y = (wndRect.top + height - m_data[i] * m_zoomY - m_deltaY);// * zoomSize;
}
// 数据点的绘制
for(UIVector<PointGroup>::const_iterator it = pgList.begin(); it != pgList.end(); ++it)
{
CFRect rect(it->vPoint.x - 2, it->vPoint.y - 2, it->vPoint.x + 2, it->vPoint.y + 2);
m_phost->GetGraphic()->DrawRect(rect, m_color, NULL);
}
// 线的绘制
if(pgList.size() > 1)
{
m_phost->GetGraphic()->DrawLine(&(pgList[0]), static_cast<int32>(pgList.size()), true, m_phost->GetWndHandle()->m_eRS );
}
}
CVector3f CVector3f::normalized() const
{
FLOAT squmrt = sqrt((FLOAT)x*x+(FLOAT)y*y+(FLOAT)z*z);
if( squmrt )
return CVector3f( (FLOAT)x/squmrt,(FLOAT)y/squmrt,(FLOAT)z/squmrt);
return *this;
}
void CEditModel::RenderBone(void)
{
if( !GetSketetalFrame() || !GetAnimateGroup()||!GetAnimateGroup()->GetAniById( m_RenderMatrix.m_CurAnimate ))
return;
RenderParam RP;
//大小
RP.m_RS.m_Material.Ambient = CColor4(0.5,0.5,0.5,1);//MOD
RP.m_RS.m_Material.Diffuse = CColor4::Green;//ADD
RP.m_RS.m_LightEnable = true;
CMatrix tScaleMat;
CMatrix tRotateMat;
CRenderPipeline::GetInst()->SetLight(0, CMainWindowTarget::GetInst()->GetGroup()->GetLightSystem()->GetGlobalLight()->GetLightStruct());//ADD
for( UINT i = 1; i < m_RenderMatrix.GetSkeletalCount(); i++ )
{
if(!m_RenderMatrix.m_pMatrixUnit[i])
continue;
tRotateMat.SetRotateZ(-CMath::half_pi);
tScaleMat.SetScale(CVector3f(m_SkeletalPos[i].m_Scale.x,m_SkeletalPos[i].m_Scale.y,m_SkeletalPos[i].m_Scale.z));
RP.m_Mat = tScaleMat*tRotateMat*m_RenderMatrix.m_pMatrixUnit[i]->GetMATRIX();
if( m_SkeletalPos[i].m_IsSelected )
RP.m_RS.m_Material.Diffuse = CColor4::Red;//MOD
else
RP.m_RS.m_Material.Diffuse = CColor4::Green;//MOD
CRenderPipeline::GetInst()->Render( &CEditorCore::TP_RO_BONE, &RP );
}
}
void CCmdMoveObject::_UnExecute()
{
// back to stationary state
COpearationLog::GetInst()->WriteOperationLog("UNDO LShift Or C move object");
CTerrainMesh * pTerrainMesh = CMapEditApp::GetInst()->GetEditingMesh();
CMapEditObject * pModel = m_diff.pObject->GetModelGroup()->GetSelfPresentation(0);
pModel->SetGroupOffset(CVector3f(0.0f,0.0f,0.0f));
// write center image info
int nCenterGridIndex = pModel->GetUserOffsetAdjustedGridIndex(m_diff.nCenterGridIndex);
SGrid & gridCenter = pTerrainMesh->GetGrid(nCenterGridIndex);
gridCenter.vecCenterObjects.push_back(m_diff.pObject);
// assumption: no pre active object exists
CToolSetModel::GetInst()->RemoveActiveObject(m_diff.pObject);
//CEditStateOpertiaonMgr::GetInst()->SetIsCalObjectWorOffset(true);
m_diff.pObject->SetCenterGridIndex(m_diff.nCenterGridIndex);
m_diff.pObject->GetModelGroup()->SetEditState(sqr::EES_PLACED);
//CEditStateOpertiaonMgr::GetInst()->SetIsCalObjectWorOffset(false);
}
int CToolSetTileBlock::GetExactGridIndex(const int nGridIndex)
{
CTerrainMesh * pTerrain = CMapEditApp::GetInst()->GetEditingMesh();
SGrid &hotgrid = pTerrain->GetGrid(nGridIndex);
CVector3f girdCenter = hotgrid.vCenter;
CTObject * p = NULL;
CVector3f v = CVector3f(0.0f, 0.0f, 0.0f);
DWORD dwGridIndexHot = CPicker::GetInst()->GetPickPos(&p,&v);
int nWhichSubIndex = 0;
if ( v.x < girdCenter.x )
{
if ( v.z < girdCenter.z )
nWhichSubIndex = 0;//0;
else
nWhichSubIndex = 2;//2;
}
else
{
if ( v.z < girdCenter.z )
nWhichSubIndex = 1;//1;
else
nWhichSubIndex = 3;//3;
}
map<int, int>::iterator iter = hotgrid.subGridIndex.begin();
for ( int i = 0 ; i < nWhichSubIndex; ++i )
++iter;
return iter->first;
}
CVector3f FileIO::getVector3f()
{
float x,y,z;
x = getFloat();
y = getFloat();
z = getFloat();
return CVector3f(x,y,z);
}
void CGUICameraCtrller::SwitchCamState()
{
if ( m_bInMove ) // 当前摄像机还在移动状态
{
//立即完成当前移动
CCamera* pCamera = (CCamera*)m_pCtrlNode;
if (!pCamera)
return;
float temp_xdis, temp_ydis, temp_zdis;
if (m_bNormal)
{
// 从近景到远景的调整
temp_xdis = (m_fCurXDis - m_LookAt.x) * GUI_CAM_XSCALE_MAX + m_LookAt.x;
temp_ydis = (m_fCurYDis - m_LookAt.y) * GUI_CAM_YSCALE_MAX + m_LookAt.y;
temp_zdis = (m_fCurZDis - m_LookAt.z) * GUI_CAM_ZSCALE_MAX + m_LookAt.z;
pCamera->SetPosition( CVector3f( temp_xdis, temp_ydis, temp_zdis ) );
}
else
{
// 从远景到近景
temp_xdis = (m_fCurXDis - m_LookAt.x) / GUI_CAM_XSCALE_MAX + m_LookAt.x;
temp_ydis = (m_fCurYDis - m_LookAt.y) / GUI_CAM_YSCALE_MAX + m_LookAt.y;
temp_zdis = (m_fCurZDis - m_LookAt.z) / GUI_CAM_ZSCALE_MAX + m_LookAt.z;
pCamera->SetPosition( CVector3f( temp_xdis, temp_ydis, temp_zdis ) );
}
m_fCurXDis = temp_xdis;
m_fCurYDis = temp_ydis;
m_fCurZDis = temp_zdis;
m_bNormal = !m_bNormal;
m_NeedReQuery = false;
m_fWearAlready = 0.0f;
m_bInMove = false;
}
// switch
m_NeedReQuery = true;
m_fWearAlready = 0.0f;
m_uCurTime = (float)((uint32)GetProcessTime());
}
CEditEllipse::CEditEllipse()
{
m_vCenter = CVector3f(0.0f, 0.0f, 0.0f);
m_fRadiusX = m_fRadiusY = 1.0f;
m_fSlices = 20;
m_dwColor = 0xffff0000;
m_fRadiusX = 40;
m_fRadiusY = 20;
}
/*
x = x0 + radiusX * cos(a)
y = y0 + radiusY * sin(a)
*/
void CEditEllipse::CreateEllipsePoints()
{
m_spherePoints.clear();
m_spherePoints.resize(m_fSlices+1);
float nDegree = 0.0f, fRadian = 0.0f;
float nAverage = 360.0f / m_fSlices;
CVector3f point = CVector3f(0.0f, 0.0f, 0.0f);
size_t m = 0;
for ( m = 0; m < m_fSlices; ++m )
{
nDegree = m * nAverage;
fRadian = fRadiaValue * nDegree;
point = m_vCenter + CVector3f(m_fRadiusX * CMath::Cos(fRadian), 0.0f, m_fRadiusY * CMath::Sin(fRadian));
m_spherePoints[m] = point;
}
m_spherePoints[m] = m_spherePoints[0];
}
void TXOctree::Split()
{
size_t esz = m_edges.size();
if (esz <= MAX_EDGE_NUMBER ||
(esz <= 2*MAX_EDGE_NUMBER && m_depth > 3) ||
(esz <= 3*MAX_EDGE_NUMBER && m_depth > 4) ||
m_depth > 6 )
{
m_isLeaf = true;
return;
}
m_isLeaf = false;
double xx[] = {m_min.GetX(), 0.5*(m_min.GetX()+m_max.GetX()), m_max.GetX()};
double yy[] = {m_min.GetY(), 0.5*(m_min.GetY()+m_max.GetY()), m_max.GetY()};
double zz[] = {m_min.GetZ(), 0.5*(m_min.GetZ()+m_max.GetZ()), m_max.GetZ()};
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
{
int m = 4*i + 2*j + k;
m_child[m] = new TXOctree( CVector3f(xx[i], yy[j], zz[k]),CVector3f(xx[i+1], yy[j+1], zz[k+1]),m_depth+1 );
size_t esz = m_edges.size();
for (int t = 0; t < esz; t++)
if (m_edges[t]->Touch(m_child[m]->GetMin(), m_child[m]->GetMax()))
m_child[m]->Insert(m_edges[t]);
if (m_child[m]->GetSize() == 0)
{
delete m_child[m];
m_child[m] = 0;
}
else m_child[m]->Split();
}
if (m_depth > 0)m_edges.clear();
}
void CForest::Initialise()
{
m_tree.Load("Resources\\Meshes\\t4\\tree.obj");
for (int i = 0; i < 10; i++)
{
float x = ((rand() / (float)RAND_MAX) - 0.5f) * CTerrain::g_terrainSize;
float z = ((rand() / (float)RAND_MAX) - 0.5f) * CTerrain::g_terrainSize;
m_positions.push_back(CVector3f(x, 0.0f, z));
}
}
void CPhysicalProp::m_Init(void)
{
this->bIncludeInPhysicsUpdate = true;
this->bInfiniteMass = false;
this->frictionLinear = 0.0f;
this->frictionLinearSquared = 0.0f;
this->frictionRotational = 0.0f;
this->rotStep = CVector3f(0.0f, 0.0f, 0.0f);
this->mass = 1.0f;
this->inverseMass = 1.0f;
return;
}
void CSword::Update(float dt){
m_position = m_playerPosition;
if (m_alive){
m_position += m_direction;
m_timer += dt;
}
if (m_timer >= 0.7f){
m_collisionObject.SetActive(false);
m_timer = 0.0f;
m_alive = false;
}
CVector3f offsetted = m_position + CVector3f(0.0f, 2.0f, 0.0f);
m_collisionObject.Update(offsetted);
}
void CPickup::Update(CVector3f c, float dt, Game *game, CAudio sound)
{
m_theta += dt * 50.0f;
if ((c - m_position).Length() < 2.0f)
{
if (m_isActive)
{
if (game->m_health != 100)
{
game->m_health = 100;
}
if (game->m_ammo != 1000)
{
game->m_ammo = 1000;
}
}
m_isActive = false;
PlaySoundA(sound);
}
// Update bounding box based on current position
m_boundingBox.Set(m_position - CVector3f(1.5, 1.5, 1.5), m_position + CVector3f(1.5, 1.5, 1.5));
}
void CGUICameraCtrller::InitCamCtrller()
{
CCamera* pCamera = (CCamera*)m_pCtrlNode;
if (!pCamera)
return;
SetCamNormalPos( 0.0f, GUI_CAM_YDIS_DFT, GUI_CAM_ZDIS_DFT );
pCamera->lookAt( CVector3f( 0, 0, 0 ));
pCamera->setFOVy(30.0f*CMath::pi/180.0f);
pCamera->setNearDist( Z_GUI_NEAR );
pCamera->setFarDist( Z_GUI_FAR );
return;
}
CSquare::CSquare(ISceneNode * pParent, string texname, float fSizeInWidth, float fSizeInDepth, DWORD dwColor) :
ISceneNode(pParent), m_strLockTextureName(texname), m_fSizeInWidth(fSizeInWidth), m_fSizeInDepth(fSizeInDepth), m_dwColor(dwColor)
{
m_vPos[0] = CVector3f(-m_fSizeInWidth*0.5f, 0.0f, -m_fSizeInDepth*0.5f);
m_vPos[1] = CVector3f(-m_fSizeInWidth*0.5f, 0.0f, m_fSizeInDepth*0.5f);
m_vPos[2] = CVector3f(m_fSizeInWidth*0.5f, 0.0f, -m_fSizeInDepth*0.5f);
m_vPos[3] = CVector3f(m_fSizeInWidth*0.5f, 0.0f, m_fSizeInDepth*0.5f);
m_dwClr[0] = dwColor;
m_dwClr[1] = dwColor;
m_dwClr[2] = dwColor;
m_dwClr[3] = dwColor;
m_vUV[0] = CVector2f(0.0f,1.0f);
m_vUV[1] = CVector2f(0.0f,0.0f);
m_vUV[2] = CVector2f(1.0f,1.0f);
m_vUV[3] = CVector2f(1.0f,0.0f);
////添加自己的SceneNode名字
//m_strSceneNodeName = "SquareSceneNode";
m_pRS = NULL;
m_pLockTexture = CRenderDevice::GetInst()->GetTexture(m_strLockTextureName.c_str());
}
void CPositionFX::PlayEffect(const string &strFXNameGroup, const string &strFXName)
{
if (!CClientRenderScene::HasInst())
{
delete this;
return;
}
CRenderScene* pRenderScene=CClientRenderScene::GetInst();
float fRatio = eGridSpanForObj / eGridSpan;
pRenderScene->AttachRenderObject(*m_pPosRenderObj,CVector3f(m_Pos.x / fRatio, 0, m_Pos.y / fRatio));
m_pPosRenderObj->AddEffect( strFXNameGroup.c_str(), strFXName.c_str(), CEffectPlayer::PLAY_ONCE, NULL );
//m_pPosRenderObj->AddPiece( RFT_ARE, strFXNameGroup.c_str(), "", strFXName.c_str() );
}
void CToolSetTileBlock::SetExactGridIndex()
{
if ( m_processParams.eEditBrushType == EBT_NORMAL )
return;
map<int, vector<int>> & vecVertexIndices = this->GetBrushSubGridIndices();
map<int, vector<int>>::iterator beg = vecVertexIndices.begin();
map<int, vector<int>>::iterator end = vecVertexIndices.end();
CTerrainMesh * pTerrain = CMapEditApp::GetInst()->GetEditingMesh();
int nGridIndex = 0, nSubGridIndex = 0, nBlockType = 0;
size_t size = 0;
DWORD drawnCnt = 0;
CVector3f center = CVector3f(0.0f, 0.0f, 0.0f);
float step = GRID_SPACE * 0.5f;
vector<int> subIndexs;
bool bSetExactBlock = false;
if ( m_processParams.eEditType == EET_WRITE )
{
nBlockType = m_processParams.eBlockTypeHot;
bSetExactBlock = true;
}
else
{
nBlockType = 0;
bSetExactBlock = false;
}
char szBlockBuf[64];
sprintf(szBlockBuf, "F1操作，设置精确阻挡：阻挡类型是 = %d", nBlockType);
COpearationLog::GetInst()->WriteOperationLog(szBlockBuf);
for ( beg; beg != end; ++ beg )
{
nGridIndex = beg->first;
size = beg->second.size();
SGrid &grid = pTerrain->GetGrid(nGridIndex);
for ( size_t i = 0; i < size; ++i )
{
grid.subGridTypes[beg->second[i]] = nBlockType;
}
grid.m_bSetExactBlock = bSetExactBlock;
}
}
TXDualEdge::TXDualEdge(TXEdge* edge, bool fac, int tp, const CVector4f& pos1, const CVector4f& pos2)
{
m_e = edge;
m_facing = fac;
m_checked = false;
m_triangles[0] = m_e->m_triangles[0];
m_triangles[1] = m_e->m_triangles[1];
m_eid[0] = m_e->GetIDInTriangle(m_triangles[0]);
m_eid[1] = m_e->GetIDInTriangle(m_triangles[1]);;
float d1, d2;
float eps = float(DBL_EPSILON);
switch (tp) {
case PX:
case NX:
d1 = MAX(eps, fabs(pos1.GetX()));
d2 = MAX(eps, fabs(pos2.GetX()));
m_dp[0] = CVector3f(pos1.GetY()/d1, pos1.GetZ()/d1, pos1.GetW()/d1);
m_dp[1] = CVector3f(pos2.GetY()/d2, pos2.GetZ()/d2, pos2.GetW()/d2);
break;
case PY:
case NY:
d1 = MAX(eps, fabs(pos1.GetY()));
d2 = MAX(eps, fabs(pos2.GetY()));
m_dp[0] = CVector3f(pos1.GetZ()/d1, pos1.GetW()/d1, pos1.GetX()/d1);
m_dp[1] = CVector3f(pos2.GetZ()/d2, pos2.GetW()/d2, pos2.GetX()/d2);
break;
case PZ:
case NZ:
d1 = MAX(eps, fabs(pos1.GetZ()));
d2 = MAX(eps, fabs(pos2.GetZ()));
m_dp[0] = CVector3f(pos1.GetW()/d1, pos1.GetX()/d1, pos1.GetY()/d1);
m_dp[1] = CVector3f(pos2.GetW()/d2, pos2.GetX()/d2, pos2.GetY()/d2);
break;
case PW:
case NW:
d1 = MAX(eps, fabs(pos1.GetW()));
d2 = MAX(eps, fabs(pos2.GetW()));
m_dp[0] = CVector3f(pos1.GetX()/d1, pos1.GetY()/d1, pos1.GetZ()/d1);
m_dp[1] = CVector3f(pos2.GetX()/d2, pos2.GetY()/d2, pos2.GetZ()/d2);
}
}
// 设置GUI相机在NORMAL状态下的位置
void CGUICameraCtrller::SetCamNormalPos( float x, float y, float z )
{
CCamera* pCamera = (CCamera*)m_pCtrlNode;
if (!pCamera)
return;
m_fCurXDis = x;
m_fCurYDis = y;
m_fCurZDis = z;
m_bNormal = true;
m_NeedReQuery = false;
m_fWearAlready = 0.0f;
m_bInMove = false;
m_LookAt.Init(0.0f, 0.0f, 1.0f);
pCamera->SetPosition( CVector3f( x, y, z ) );
return;
}
CVector3f CVector3f::canonized()const
{
FLOAT tmp1 = pitch,tmp2 = heading,tmp3 = bank;
tmp1 *= H3DMath::M_DEG2RAD;
tmp2 *= H3DMath::M_DEG2RAD;
tmp3 *= H3DMath::M_DEG2RAD;
tmp1 = WRAPPI(tmp1);
if(tmp1 < -H3DMath::HALF_PI)
{
tmp1 = -(H3DMath::PI+tmp1);
tmp2 += H3DMath::PI;
tmp3 += H3DMath::PI;
}
else if(tmp1 > H3DMath::HALF_PI)
{
tmp1 = H3DMath::PI - tmp1;
tmp2 += H3DMath::PI;
tmp3 += H3DMath::PI;
}
//check gimbal lock
if(fabs(tmp1) > (H3DMath::HALF_PI - 1e-4))
{
tmp2 += tmp3;
tmp3 = 0.0;
}
else
{
tmp3 = WRAPPI(tmp3);
}
tmp2 = WRAPPI(tmp2);
assert(tmp1 >= -H3DMath::HALF_PI && tmp1 <= H3DMath::HALF_PI);
assert(tmp2 >= -H3DMath::PI && tmp2 <= H3DMath::PI);
assert(tmp3 >= -H3DMath::PI && tmp3 <= H3DMath::PI);
tmp1 *= H3DMath::M_RAD2DEG;
tmp2 *= H3DMath::M_RAD2DEG;
tmp3 *= H3DMath::M_RAD2DEG;
return CVector3f(tmp1,tmp2,tmp3);
}
