Air::U1 Frustum::IsVisiable( const OrientedBox& box ){
Float3 v[8];
Float3 vCenter(box.Center);
Float3 vExtents(box.Extents);
v[0] = vCenter + Float3(-1,-1,1)*vExtents;
v[1] = vCenter + Float3(1,-1,-1)*vExtents;
v[2] = vCenter + Float3(1,-1,1)*vExtents;
v[3] = vCenter + Float3(-1,-1,-1)*vExtents;
v[4] = vCenter + Float3(-1,1,1)*vExtents;
v[5] = vCenter + Float3(1,1,-1)*vExtents;
v[6] = vCenter + Float3(1,1,1)*vExtents;
v[7] = vCenter + Float3(-1,1,-1)*vExtents;
//旋转8个顶点
Float4 q(box.Orientation);
for(U32 i=0;i<8;i++){
v[i] = q*v[i];
}
if(m_vecPlane[enFS_Near].GetSide(v,8) == enPS_Negative)
return false;
if(m_vecPlane[enFS_Left].GetSide(v,8) == enPS_Negative)
return false;
if(m_vecPlane[enFS_Right].GetSide(v,8) == enPS_Negative)
return false;
if(m_vecPlane[enFS_Top].GetSide(v,8) == enPS_Negative)
return false;
if(m_vecPlane[enFS_Bottom].GetSide(v,8) == enPS_Negative)
return false;
if(m_vecPlane[enFS_Far].GetSide(v,8) == enPS_Negative)
return false;
return true;
}
HRESULT TestApplication1::OnCreateDevice(ID3D10Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext)
{
HRESULT hr;
D3DXVECTOR3 vCenter(0.25767413f, -28.503521f, 111.00689f);
FLOAT fObjectRadius = 378.15607f;
D3DXMatrixTranslation(&_mCenterMesh, -vCenter.x, -vCenter.y, -vCenter.z);
D3DXMATRIXA16 m;
D3DXMatrixRotationY(&m, D3DX_PI);
_mCenterMesh *= m;
D3DXMatrixRotationX(&m, D3DX_PI / 2.0f);
_mCenterMesh *= m;
// Create our vertex input layout
_shaderutil.SetShaderName(L"Shader\\SpecularMapping_2.fx", "SpecularMapping");
_shaderutil.ShaderSetting(*pd3dDevice);
// Load the mesh
V_RETURN(_Mesh.Create(pd3dDevice, L"Model\\Sphere.sdkmesh", true));
// Setup the camera's view parameters
D3DXVECTOR3 vecEye(0.0f, 0.0f, -15.0f);
D3DXVECTOR3 vecAt(0.0f, 0.0f, -0.0f);
_camera.SetViewParams(&vecEye, &vecAt);
_camera.SetRadius(fObjectRadius * 3.0f, fObjectRadius * 0.5f, fObjectRadius * 10.0f);
return S_OK;
}
Air::U1 Frustum::IsVisiable( const AxisAlignedBox& box ){
Float3 v[8];
Float3 vCenter(box.Center);
Float3 vExtents(box.Extents);
v[0] = vCenter + Float3(-1,-1,1)*vExtents;
v[1] = vCenter + Float3(1,-1,-1)*vExtents;
v[2] = vCenter + Float3(1,-1,1)*vExtents;
v[3] = vCenter + Float3(-1,-1,-1)*vExtents;
v[4] = vCenter + Float3(-1,1,1)*vExtents;
v[5] = vCenter + Float3(1,1,-1)*vExtents;
v[6] = vCenter + Float3(1,1,1)*vExtents;
v[7] = vCenter + Float3(-1,1,-1)*vExtents;
if(m_vecPlane[enFS_Near].GetSide(v,8) == enPS_Negative)
return false;
if(m_vecPlane[enFS_Left].GetSide(v,8) == enPS_Negative)
return false;
if(m_vecPlane[enFS_Right].GetSide(v,8) == enPS_Negative)
return false;
if(m_vecPlane[enFS_Top].GetSide(v,8) == enPS_Negative)
return false;
if(m_vecPlane[enFS_Bottom].GetSide(v,8) == enPS_Negative)
return false;
if(m_vecPlane[enFS_Far].GetSide(v,8) == enPS_Negative)
return false;
return true;
};
HRESULT KG3DRotationCoordinateOld::SetMode(DWORD dwMode)
{
m_dwMode = dwMode;
_ASSERTE(NULL != m_pAttachScene);
switch (m_dwMode)
{
case KG3DCOORD_WORLD :
{
/*m_matEntityWorld = m_EntityList.GetWorldMatrix();
D3DXMatrixIdentity(&m_matCoord);
m_matCoord._41 = m_matEntityWorld._41;
m_matCoord._42 = m_matEntityWorld._42;
m_matCoord._43 = m_matEntityWorld._43;*/
D3DXVECTOR3 vCenter(0,0,0);
KSF::GetSelectionCenter(m_pAttachScene->GetSelectionTool(), vCenter);
D3DXMatrixTranslation(&m_matCoord, vCenter.x, vCenter.y, vCenter.z);
m_matEntityWorld = m_matCoord;
}
break;
case KG3DCOORD_LOCAL :
{
/*m_matCoord = m_EntityList.GetWorldMatrix();*/
D3DXVECTOR3 vCenter(0,0,0);
KSF::GetSelectionCenter(m_pAttachScene->GetSelectionTool(), vCenter);
D3DXMatrixTranslation(&m_matCoord, vCenter.x, vCenter.y, vCenter.z);
D3DXVECTOR3 t;
D3DXVECTOR3 s;
D3DXMATRIX q;
D3DXMATRIX m;
MatrixExract(s, t, q, &m_matCoord);
D3DXMatrixTranslation(&m, t.x, t.y, t.z);
m_matCoord = q * m;
}
break;
default :
ASSERT(false);
break;
}
return S_OK;
}
bool CCubeBox::Collision(D3DXVECTOR3& vGo, D3DXVECTOR3& vPos)
{
FLOAT StdDist[3] = { m_wx/2, m_wy/2, m_wz/2 };
//矩形中心
D3DXVECTOR3 vCenter( m_x + StdDist[0], m_y + StdDist[1], m_z + StdDist[2]);
//原位置指向中心
D3DXVECTOR3 D = vCenter - vPos;
//若方向相反
//if (D3DXVec3Dot(&vGo, &D) <= 0) return false;
//长宽高单位向量
D3DXVECTOR3 vSub[3];
vSub[0] = D3DXVECTOR3( 1, 0, 0 );
vSub[1] = D3DXVECTOR3( 0, 1, 0 );
vSub[2] = D3DXVECTOR3( 0, 0, 1 );
//前进方向分量
FLOAT vGoSub[3];
//距中心分量
FLOAT vDSub[3];
for (int i = 0; i < 3; i++)
{
D3DXVec3TransformCoord(&vSub[i], &vSub[i], &m_matRot);
vGoSub[i] = D3DXVec3Dot(&vGo, &vSub[i]);
vDSub[i] = D3DXVec3Dot(&D, &vSub[i]);
}
//二者的差距
FLOAT inner[3];
for (int i = 0; i<3; i++)
{
inner[i] = StdDist[i] - abs(vDSub[i] - vGoSub[i])+0.5f;
//有一个<0，就没碰
if (inner[i] < 0) return false;
}
//三个都大于0
int Min = 0;
FLOAT s = 100000.0f;
for (int i =0; i < 3; i++)
{
if (inner[i] / abs(vGoSub[i]) < s)
{
s = inner[i] / abs(vGoSub[i]);
Min = i;
}
}
//只修正最小一个分量
if (vGoSub[Min] > 0)
{
vGoSub[Min] = vGoSub[Min] - inner[Min];
}else{
vGoSub[Min] = vGoSub[Min] + inner[Min];
}
//最后生成修正值
vGo = vGoSub[0] * vSub[0] + vGoSub[1] * vSub[1] + vGoSub[2] * vSub[2];
return true;
}
//-----------------------------------------------------------------------
bool gkObjectManager::checkSelected( uint8 type, f32 size, bool draging )
{
// first of all, get the 3 axis end point at screenspace [8/25/2011 Kaiming-Desktop]
Vec2 vCursor = GetIEditor()->getMainViewport()->getCursorOnClientScreen();
Vec3 vAxis3D;
Vec3 vCenter3D;
Vec3 vCenterReal = ms_pCurrentPick->getWorldPosition();
Vec3 vDirReal(0,0,0);
vCenter3D = gEnv->pRenderer->ProjectScreenPos( vCenterReal );
switch(type)
{
case GKSTUDIO_AXIS_X:
vDirReal = ms_pCurrentPick->getOrientation().GetColumn0();
break;
case GKSTUDIO_AXIS_Y:
vDirReal = ms_pCurrentPick->getOrientation().GetColumn1();
break;
case GKSTUDIO_AXIS_Z:
vDirReal = ms_pCurrentPick->getOrientation().GetColumn2();
break;
}
vAxis3D = gEnv->pRenderer->ProjectScreenPos( ms_pCurrentPick->getWorldPosition() + size * vDirReal );
// make two 2D vector
Vec2 vCenter(vCenter3D.x, vCenter3D.y);
Vec2 vAxis(vAxis3D.x, vAxis3D.y);
Vec2 vPoint = vCursor - vCenter;
Vec2 vAxisPoint = vAxis - vCenter;
ms_dragInvertX = vAxisPoint.x > 0 ? 1 : -1;
ms_dragInvertY = vAxisPoint.y > 0 ? 1 : -1;
// judge this
if (vPoint.GetLength() - vAxisPoint.GetLength() < size + 2.0f)
{
vPoint.Normalize();
vAxisPoint.Normalize();
if (vPoint.Dot(vAxisPoint) > 0.95f)
return true;
}
return false;
}
void ScratchPad_DrawFace( IScratchPad3D *pPad, dface_t *f, int iFaceNumber, const CSPColor &faceColor, const Vector &vOffset )
{
// Draw the face's outline, then put text for its face index on it too.
CUtlVector<Vector> points;
for ( int iEdge = 0; iEdge < f->numedges; iEdge++ )
{
int v;
int se = dsurfedges[f->firstedge + iEdge];
if ( se < 0 )
v = dedges[-se].v[1];
else
v = dedges[se].v[0];
dvertex_t *dv = &dvertexes[v];
points.AddToTail( dv->point );
}
// Draw the outline.
Vector vCenter( 0, 0, 0 );
for ( int iEdge=0; iEdge < points.Count(); iEdge++ )
{
pPad->DrawLine( CSPVert( points[iEdge]+vOffset, faceColor ), CSPVert( points[(iEdge+1)%points.Count()]+vOffset, faceColor ) );
vCenter += points[iEdge];
}
vCenter /= points.Count();
vCenter += vOffset;
// Draw the text.
if ( iFaceNumber != -1 )
{
char str[64];
Q_snprintf( str, sizeof( str ), "%d", iFaceNumber );
CTextParams params;
params.m_bCentered = true;
params.m_bOutline = true;
params.m_flLetterWidth = 2;
params.m_vColor.Init( 1, 0, 0 );
VectorAngles( dplanes[f->planenum].normal, params.m_vAngles );
params.m_bTwoSided = true;
params.m_vPos = vCenter;
pPad->DrawText( str, params );
}
}
HRESULT KG3DRotationCoordinateOld::FrameMove()
{
HRESULT hResult = E_FAIL;
HRESULT hRetCode = E_FAIL;
IEKG3DSceneOutputWnd *piCurOutputWnd = NULL;
D3DXVECTOR3 vCoordX;
D3DXVECTOR3 vCoordY;
D3DXVECTOR3 vCoordZ;
switch (m_dwMode)
{
case KG3DCOORD_WORLD:
{
/* D3DXMATRIX matEntity = m_EntityList.GetWorldMatrix();
D3DXMatrixIdentity(&m_matCoord);
m_matCoord._41 = matEntity._41;
m_matCoord._42 = matEntity._42;
m_matCoord._43 = matEntity._43;*/
D3DXVECTOR3 vCenter(0,0,0);
KSF::GetSelectionCenter(m_pAttachScene->GetSelectionTool(), vCenter);
D3DXMatrixTranslation(&m_matCoord, vCenter.x, vCenter.y, vCenter.z);
}
break;
case KG3DCOORD_LOCAL :
{
//m_matCoord = m_EntityList.GetWorldMatrix();
D3DXVECTOR3 vCenter(0,0,0);
KSF::GetSelectionCenter(m_pAttachScene->GetSelectionTool(), vCenter);
D3DXMatrixTranslation(&m_matCoord, vCenter.x, vCenter.y, vCenter.z);
D3DXVECTOR3 t;
D3DXVECTOR3 s;
D3DXMATRIX q;
D3DXMATRIX m;
MatrixExract(s, t, q, &m_matCoord);
D3DXMatrixTranslation(&m, t.x, t.y, t.z);
m_matCoord = q * m;
}
break;
default :
ASSERT(false);
break;
}
vCoordX = D3DXVECTOR3(m_matCoord._11, m_matCoord._12, m_matCoord._13);
vCoordY = D3DXVECTOR3(m_matCoord._21, m_matCoord._22, m_matCoord._23);
vCoordZ = D3DXVECTOR3(m_matCoord._31, m_matCoord._32, m_matCoord._33);
if (!m_nMoveFlag && m_pAttachScene && m_pCoordMesh && /*m_EntityList.GetSize()*/0 != m_pAttachScene->GetSelectionTool().GetSelectionCount())
{
D3DXVECTOR3 vOrg;
D3DXVECTOR3 vDir;
hRetCode = m_pAttachScene->GetCurOutputWnd(&piCurOutputWnd);
KGLOG_COM_PROCESS_ERROR(hRetCode);
piCurOutputWnd->GetPickRay(&vOrg, &vDir, NULL);
D3DXVec3Normalize(&vDir, &vDir);
m_dwCurrSelCoord = GetSelCoord(vOrg, vDir);
}
if (m_nMoveFlag && m_pAttachScene && m_pCoordMesh && /*m_EntityList.GetSize()*/0 != m_pAttachScene->GetSelectionTool().GetSelectionCount())
{
D3DXVECTOR3 vModelPosition;
D3DXVECTOR3 vOrg;
D3DXVECTOR3 vDir;
D3DXVECTOR3 vCurrOrig;
D3DXMATRIX matWorldMatrix;
hRetCode = m_pAttachScene->GetCurOutputWnd(&piCurOutputWnd);
KG_PROCESS_ERROR(piCurOutputWnd);
piCurOutputWnd->GetPickRay(&vOrg, &vDir, NULL);
matWorldMatrix = m_matEntityWorld;
vModelPosition.x = matWorldMatrix._41;
vModelPosition.y = matWorldMatrix._42;
vModelPosition.z = matWorldMatrix._43;
D3DXVECTOR3 vCurrCross;
KG_PROCESS_ERROR(
D3DXPlaneIntersectLine(
&vCurrCross,
&m_currSelPane,
&vOrg,
&(vOrg + vDir * 10000000.0f)
)
);
D3DXVECTOR3 vCurrDir;
D3DXVECTOR3 vPrevDir;
D3DXVec3Normalize(&vCurrDir, &(vCurrCross - vModelPosition));
D3DXVec3Normalize(&vPrevDir, &(m_vPrevCross - vModelPosition));
D3DXVECTOR3 vCross;
FLOAT fDot = D3DXVec3Dot(&vCurrDir, &vPrevDir);
if (fDot > 1.0f)
fDot = 1.0f;
D3DXVec3Cross(&vCross, &vCurrDir, &vPrevDir);
FLOAT fAngel = 0.0f;
D3DXVec3Normalize(&vCross, &vCross);
D3DXVec3Normalize(&m_currSelNormal, &m_currSelNormal);
if (fabs(D3DXVec3Dot(&vCross, &m_currSelNormal) - 1) <= 0.05)
fAngel = -acosf(fDot);
else
fAngel = acosf(fDot);
D3DXMATRIX mat;
switch (m_dwCurrSelCoord)
{
case 0 :
D3DXMatrixRotationAxis(&mat, &vCoordY, fAngel);
m_fAngelY += fAngel;
break;
case 1 :
D3DXMatrixRotationAxis(&mat, &vCoordX, fAngel);
m_fAngelX += fAngel;
break;
case 2 :
D3DXMatrixRotationAxis(&mat, &vCoordZ, fAngel);
m_fAngelZ += fAngel;
break;
default :
break;
}
//m_EntityList.Rotation(mat);
KSF::SelectionRotationEntity(m_pAttachScene->GetSelectionTool(), mat);
m_vPrevCross = vCurrCross;
}
IEKG3DSceneEditorBase* pEditorBase = NULL;
m_pAttachScene->GetSceneEditorBase(&pEditorBase);
if (pEditorBase)
pEditorBase->SetRtsActive(m_dwCurrSelCoord != 0xffffffff);
hResult = S_OK;
Exit0:
return hResult;
}
HRESULT KG3DRotationCoordinateOld::RotateBegin()
{
//m_matEntityWorld = m_EntityList.GetWorldMatrix();
{
D3DXVECTOR3 vCenter(0,0,0);
KSF::GetSelectionCenter(m_pAttachScene->GetSelectionTool(), vCenter);
D3DXMatrixTranslation(&m_matEntityWorld, vCenter.x, vCenter.y, vCenter.z);
}
m_vBeginCross.x = m_matEntityWorld._41;
m_vBeginCross.y = m_matEntityWorld._42;
m_vBeginCross.z = m_matEntityWorld._43;
m_vPrevCross = m_vBeginCross;
HRESULT hResult = E_FAIL;
HRESULT hRetCode = E_FAIL;
D3DXVECTOR3 vOrg;
D3DXVECTOR3 vDir;
D3DXMATRIX matWorldInv;
D3DXVECTOR3 vCrossXZ;
D3DXVECTOR3 vCrossYZ;
D3DXVECTOR3 vCrossXY;
D3DXPLANE planeXZ;
D3DXPLANE planeXY;
D3DXPLANE planeYZ;
D3DXVECTOR3 vPoint = D3DXVECTOR3(m_matCoord._41, m_matCoord._42, m_matCoord._43);
D3DXVECTOR3 vNorXZ = D3DXVECTOR3(m_matCoord._21, m_matCoord._22, m_matCoord._23);
D3DXVECTOR3 vNorXY = D3DXVECTOR3(m_matCoord._31, m_matCoord._32, m_matCoord._33);
D3DXVECTOR3 vNorYZ = D3DXVECTOR3(m_matCoord._11, m_matCoord._12, m_matCoord._13);
D3DXVECTOR3 vCross;
IEKG3DSceneOutputWnd *piCurOutputWnd = NULL;
KG_PROCESS_ERROR(m_dwCurrSelCoord != 0xFFFFFFFF);
//KG_PROCESS_ERROR(m_pAttachScene);
//KG_PROCESS_ERROR(m_EntityList.GetSize());
_ASSERTE(NULL != m_pAttachScene);
KG_PROCESS_ERROR(0 != m_pAttachScene->GetSelectionTool().GetSelectionCount());
hRetCode = m_pAttachScene->GetCurOutputWnd(&piCurOutputWnd);
KGLOG_COM_PROCESS_ERROR(hRetCode);
piCurOutputWnd->GetPickRay(&vOrg, &vDir, NULL);
D3DXPlaneFromPointNormal(
&planeXZ,
&vPoint,
&vNorXZ
);
D3DXPlaneFromPointNormal(
&planeXY,
&vPoint,
&vNorXY
);
D3DXPlaneFromPointNormal(
&planeYZ,
&vPoint,
&vNorYZ
);
D3DXPlaneNormalize(&planeYZ, &planeYZ);
D3DXPlaneNormalize(&planeXZ, &planeXZ);
D3DXPlaneNormalize(&planeXY, &planeXY);
switch (m_dwCurrSelCoord)
{
case 0 : // y
KG_PROCESS_ERROR(
D3DXPlaneIntersectLine(
&vCross,
&planeXZ,
&vOrg,
&(vOrg + vDir * 10000000.0f)
)
);
m_vPrevCross = vCross;
m_currSelPane = planeXZ;
m_currSelNormal = vNorXZ;
break;
case 1 : // x
KG_PROCESS_ERROR(
D3DXPlaneIntersectLine(
&vCross,
&planeYZ,
&vOrg,
&(vOrg + vDir * 10000000.0f)
)
);
m_vPrevCross = vCross;
m_currSelPane = planeYZ;
m_currSelNormal = vNorYZ;
break;
case 2 : // z
KG_PROCESS_ERROR(
D3DXPlaneIntersectLine(
&vCross,
&planeXY,
&vOrg,
&(vOrg + vDir * 10000000.0f)
)
);
m_vPrevCross = vCross;
m_currSelPane = planeXY;
m_currSelNormal = vNorXY;
break;
default :
ASSERT(FALSE);
break;
}
m_vBeginCross = m_vPrevCross;
m_fAngelX = 0.0f;
m_fAngelY = 0.0f;
m_fAngelZ = 0.0f;
m_nMoveFlag = TRUE;
hResult = S_OK;
Exit0:
return hResult;
}
void CHUD::UpdateMissionObjectiveIcon(EntityId objective, int friendly, FlashOnScreenIcon iconType, bool forceNoOffset, Vec3 rotationTarget)
{
IEntity *pObjectiveEntity = GetISystem()->GetIEntitySystem()->GetEntity(objective);
if(!pObjectiveEntity) return;
AABB box;
pObjectiveEntity->GetWorldBounds(box);
Vec3 vWorldPos = Vec3(0,0,0);
SEntitySlotInfo info;
int slotCount = pObjectiveEntity->GetSlotCount();
for(int i=0; i<slotCount; ++i)
{
if (pObjectiveEntity->GetSlotInfo(i, info))
{
if (info.pCharacter)
{
int16 id = info.pCharacter->GetISkeletonPose()->GetJointIDByName("objectiveicon");
if (id >= 0)
{
//vPos = pCharacter->GetISkeleton()->GetHelperPos(helper);
vWorldPos = info.pCharacter->GetISkeletonPose()->GetAbsJointByID(id).t;
if (!vWorldPos.IsZero())
{
vWorldPos = pObjectiveEntity->GetSlotWorldTM(i).TransformPoint(vWorldPos);
break;
}
}
}
}
}
if(vWorldPos == Vec3(0,0,0))
vWorldPos = pObjectiveEntity->GetWorldPos();
if(!forceNoOffset)
vWorldPos.z += 2.0f;
Vec3 vEntityScreenSpace;
m_pRenderer->ProjectToScreen( vWorldPos.x, vWorldPos.y, vWorldPos.z, &vEntityScreenSpace.x, &vEntityScreenSpace.y, &vEntityScreenSpace.z);
Vec3 vEntityTargetSpace;
bool useTarget = false;
if(!rotationTarget.IsZero())
{
m_pRenderer->ProjectToScreen( rotationTarget.x, rotationTarget.y, rotationTarget.z, &vEntityTargetSpace.x, &vEntityTargetSpace.y, &vEntityTargetSpace.z);
useTarget = true;
}
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetClientActor());
bool bBack = false;
if (IMovementController *pMV = pActor->GetMovementController())
{
SMovementState state;
pMV->GetMovementState(state);
Vec3 vLook = state.eyeDirection;
Vec3 vDir = vWorldPos - pActor->GetEntity()->GetWorldPos();
float fDot = vLook.Dot(vDir);
if(fDot<0.0f)
bBack = true;
}
bool bLeft(false), bRight(false), bTop(false), bBottom(false);
if(vEntityScreenSpace.z > 1.0f && bBack)
{
Vec2 vCenter(50.0f, 50.0f);
Vec2 vTarget(-vEntityScreenSpace.x, -vEntityScreenSpace.y);
Vec2 vScreenDir = vTarget - vCenter;
vScreenDir = vCenter + (100.0f * vScreenDir.NormalizeSafe());
vEntityScreenSpace.y = vScreenDir.y;
vEntityScreenSpace.x = vScreenDir.x;
useTarget = false;
}
if(vEntityScreenSpace.x < 2.0f)
{
bLeft = true;
vEntityScreenSpace.x = 2.0f;
useTarget = false;
}
if(vEntityScreenSpace.x > 98.0f)
{
bRight = true;
vEntityScreenSpace.x = 98.0f;
useTarget = false;
}
if(vEntityScreenSpace.y < 2.01f)
{
bTop = true;
vEntityScreenSpace.y = 2.0f;
useTarget = false;
}
if(vEntityScreenSpace.y > 97.99f)
{
bBottom = true;
vEntityScreenSpace.y = 98.0f;
useTarget = false;
}
float fScaleX = 0.0f;
float fScaleY = 0.0f;
float fHalfUselessSize = 0.0f;
GetProjectionScale(&m_animMissionObjective,&fScaleX,&fScaleY,&fHalfUselessSize);
if(bLeft && bTop)
{
iconType = eOS_TopLeft;
}
else if(bLeft && bBottom)
{
iconType = eOS_BottomLeft;
}
else if(bRight && bTop)
{
iconType = eOS_TopRight;
}
else if(bRight && bBottom)
{
iconType = eOS_BottomRight;
}
else if(bLeft)
{
iconType = eOS_Left;
}
else if(bRight)
{
iconType = eOS_Right;
}
else if(bTop)
{
iconType = eOS_Top;
}
else if(bBottom)
{
iconType = eOS_Bottom;
}
float rotation = 0.0f;
if(useTarget)
{
float diffX = (vEntityScreenSpace.x*fScaleX+fHalfUselessSize+16.0f) - (vEntityTargetSpace.x*fScaleX+fHalfUselessSize+16.0f);
float diffY = (vEntityScreenSpace.y*fScaleY) - (vEntityTargetSpace.y*fScaleY);
Vec2 dir(diffX, diffY);
dir.NormalizeSafe();
float fAngle;
if(dir.y < 0)
{
fAngle = RAD2DEG(acos_tpl(dir.x));
}
else
{
fAngle = RAD2DEG(gf_PI2-acos_tpl(dir.x));
}
rotation = fAngle - 90.0f;
}
int iMinDist = g_pGameCVars->hud_onScreenNearDistance;
int iMaxDist = g_pGameCVars->hud_onScreenFarDistance;
float fMinSize = g_pGameCVars->hud_onScreenNearSize;
float fMaxSize = g_pGameCVars->hud_onScreenFarSize;
CActor *pPlayerActor = static_cast<CActor *>(gEnv->pGame->GetIGameFramework()->GetClientActor());
float fDist = (vWorldPos-pPlayerActor->GetEntity()->GetWorldPos()).len();
float fSize = 1.0;
if(fDist<=iMinDist)
{
fSize = fMinSize;
}
else if(fDist>=iMaxDist)
{
fSize = fMaxSize;
}
else if(iMaxDist>iMinDist)
{
float fA = ((float)iMaxDist - fDist);
float fB = (float)(iMaxDist - iMinDist);
float fC = (fMinSize - fMaxSize);
fSize = ((fA / fB) * fC) + fMaxSize;
}
float centerX = 50.0;
float centerY = 50.0;
m_missionObjectiveNumEntries += FillUpMOArray(&m_missionObjectiveValues, objective, vEntityScreenSpace.x*fScaleX+fHalfUselessSize+16.0f, vEntityScreenSpace.y*fScaleY, iconType, friendly, (int)fDist, fSize*fSize, -rotation);
bool nearCenter = (pow(centerX-vEntityScreenSpace.x+1.5f,2.0f)+pow(centerY-vEntityScreenSpace.y+2.5f,2.0f))<16.0f;
if(nearCenter && (gEnv->bMultiplayer || m_pHUDScopes->IsBinocularsShown()))
{
m_objectiveNearCenter = objective;
}
}
// Calculate the quantization factors
void CIFXPointSetEncoder::CalculateQuantizationFactorsX()
{
U32 uQualityFactor = 1000;
m_pPointSetResource->GetQualityFactorX(uQualityFactor,IFXAuthorPointSetResource::POSITION_QUALITY);
if(1000 == uQualityFactor) {
m_fQuantPosition = (F32) pow(2.0,18.0);
} else {
m_fQuantPosition = (F32) pow(1.0076537604105041221998506395494,uQualityFactor+545.0);
}
// Scale m_fQuantPosition by the radius of the bounding sphere
IFXASSERT(m_pAuthorPointSet);
// get the Point set description
const IFXAuthorPointSetDesc* pPointSetDescription = m_pAuthorPointSet->GetMaxPointSetDesc();
IFXASSERT(pPointSetDescription);
IFXASSERT(pPointSetDescription->m_numPositions > 0);
IFXVector3* pPosition = NULL;
IFXCHECKX(m_pAuthorPointSet->GetPositions(&pPosition));
// Calculate the center of the bounding sphere
IFXVector3 vMin(pPosition[0]), vMax(pPosition[0]);
U32 i = 0;
U32 uNumPositions = pPointSetDescription->m_numPositions;
for(i = 1; i < uNumPositions ; i++) {
vMin.X() += (pPosition[i].X() - vMin.X()) * (pPosition[i].X() < vMin.X());
vMin.Y() += (pPosition[i].Y() - vMin.Y()) * (pPosition[i].Y() < vMin.Y());
vMin.Z() += (pPosition[i].Z() - vMin.Z()) * (pPosition[i].Z() < vMin.Z());
vMax.X() += (pPosition[i].X() - vMax.X()) * (pPosition[i].X() > vMax.X());
vMax.Y() += (pPosition[i].Y() - vMax.Y()) * (pPosition[i].Y() > vMax.Y());
vMax.Z() += (pPosition[i].Z() - vMax.Z()) * (pPosition[i].Z() > vMax.Z());
}
IFXVector3 vCenter(vMin);
vCenter.Add(vMax);
vCenter.Scale(0.5f);
// Calculate the radius of the bounding sphere
F32 fRadiusSquared = 0.0f;
F32 fDistanceSquared = 0.0f;
for(i=0; i < uNumPositions; i++) {
fDistanceSquared = vCenter.CalcDistanceSquaredFrom(pPosition[i]);
fRadiusSquared += (fDistanceSquared - fRadiusSquared) * (fDistanceSquared > fRadiusSquared);
}
// Scale the position quantization factor by the radius of the bounding sphere
if(fRadiusSquared > 0.0f) {
m_fQuantPosition /= sqrtf(fRadiusSquared);
}
// Limit quantization factor to fit quantized results in 32 bit unsigned integer
{
// Find position coordinate farthest from the origin
F32 fMaxPositionCoordinate;
fMaxPositionCoordinate = IFXMAX(fabs(vMax.X()),fabs(vMax.Y()));
fMaxPositionCoordinate = IFXMAX(fMaxPositionCoordinate,fabs(vMax.Z()));
fMaxPositionCoordinate = IFXMAX(fMaxPositionCoordinate,fabs(vMin.X()));
fMaxPositionCoordinate = IFXMAX(fMaxPositionCoordinate,fabs(vMin.Y()));
fMaxPositionCoordinate = IFXMAX(fMaxPositionCoordinate,fabs(vMin.Z()));
F32 fLimit = (F32) (0xFFFFFE00); // (F32) (0xFFFFFE00)
F32 fMaxQuantPosition = fLimit / fMaxPositionCoordinate;
// Clamp position quantization factor
m_fQuantPosition = IFXMIN(m_fQuantPosition,fMaxQuantPosition);
}
m_pPointSetResource->GetQualityFactorX(uQualityFactor,IFXAuthorPointSetResource::NORMAL_QUALITY);
if(1000 == uQualityFactor) {
m_fQuantNormal = (F32) pow(2.0,14.0);
} else {
m_fQuantNormal = (F32) pow(1.0048638204237854409678879459798,uQualityFactor+857.0);
}
m_pPointSetResource->GetQualityFactorX(uQualityFactor,IFXAuthorPointSetResource::TEXCOORD_QUALITY);
if(1000 == uQualityFactor) {
m_fQuantTexCoord = (F32) pow(2.0,14.0);
} else {
m_fQuantTexCoord = (F32) pow(1.0048638204237854409678879459798,uQualityFactor+857.0);
}
m_pPointSetResource->GetQualityFactorX(uQualityFactor,IFXAuthorPointSetResource::DIFFUSE_QUALITY);
if(1000 == uQualityFactor) {
m_fQuantDiffuseColor = (F32) pow(2.0,14.0);
} else {
m_fQuantDiffuseColor = (F32) pow(1.0022294514890519310704865897552,uQualityFactor+1741.0);
}
m_pPointSetResource->GetQualityFactorX(uQualityFactor,IFXAuthorPointSetResource::SPECULAR_QUALITY);
if(1000 == uQualityFactor) {
m_fQuantSpecularColor = (F32) pow(2.0,14.0);
} else {
m_fQuantSpecularColor = (F32) pow(1.0022294514890519310704865897552,uQualityFactor+1741.0);
}
m_fInverseQuantPosition = (F32) 1.0 / m_fQuantPosition;
m_fInverseQuantNormal = (F32) 1.0 / m_fQuantNormal;
m_fInverseQuantTexCoord = (F32) 1.0 / m_fQuantTexCoord;
m_fInverseQuantDiffuseColor = (F32) 1.0 /m_fQuantDiffuseColor;
m_fInverseQuantSpecularColor = (F32) 1.0 /m_fQuantSpecularColor;
}
