bool Turret::isTargetable (Player *player, float *minDist, float useRange)
{
if (player && player->getTeam () != getTeam() && player->getVisibleToTeam (getTeam()) && !player->isDead())
{
if (const char* script = scriptName("verifyTarget")) {
const char* pRet = Console->evaluatef("%s(%d);", script, player->getId());
if (pRet[0] == 'F' || pRet[0] == 'f')
return false;
}
Point3F playerPos = player->getLeadCenter();
float dist = m_distf (getBoxCenter(), playerPos);
if (dist < useRange)
targetsTracked++;
if (dist < *minDist)
{
TMat3F invMat;
getNodeOffset (&invMat, "dummy muzzle", gunNode);
invMat.inverse();
m_mul (Point3F (playerPos.x, playerPos.y, playerPos.z), invMat, &playerPos);
float ele = elevation (playerPos.x, playerPos.y, playerPos.z);
float rotz = rotation (-playerPos.x, -playerPos.y);
if (!inDeadZone (rotz, ele))
{
SimContainerQuery collisionQuery;
collisionQuery.id = getId();
collisionQuery.type = -1;
collisionQuery.mask = SimTerrainObjectType | SimInteriorObjectType;
collisionQuery.detail = SimContainerQuery::DefaultDetail;
collisionQuery.box.fMin = getBoxCenter();
collisionQuery.box.fMax = player->getLeadCenter();
SimCollisionInfo collisionInfo;
SimContainer* root = findObject(manager,SimRootContainerId,root);
root->findLOS(collisionQuery, &collisionInfo);
if (!collisionInfo.object || collisionInfo.object == player)
{
*minDist = dist;
return true;
}
}
}
}
return false;
}
Point3F Player::getLeadCenter (void)
{
if (mount)
return mount->getLinearPosition ();
else
return getBoxCenter ();
}
bool Turret::detectItem(GameBase *object)
{
Point3F forward,objectVec = object->getBoxCenter() - getBoxCenter();
objectVec.normalize();
getEyeTransform().getRow(1,&forward);
float dot = m_dot (forward, objectVec);
if (dot >= data->FOV)
return Parent::detectItem (object);
return false;
}
void Player::getThrowVector(Point3F* pos,Point3F* vec)
{
RMat3F view,mat;
// Add a small upward component to the pitch to
// throw the item up a little.
float offset = 0.5 * cos(viewPitch);
view.set(EulerF(viewPitch + offset,0.0f,0.0f));
m_mul(view,(RMat3F&)getTransform(),&mat);
Point3F vv(0,1,0);
m_mul(vv,mat,vec);
*pos = getBoxCenter();
}
Point3D getCenter(){
Point3D center= getBoxCenter();
/*
center.x = 0;
center.y = 0;
center.z = 0;
for (int i=0;i<vertex.size();++i){
center.x += vertex[i].x;
center.y += vertex[i].y;
center.z += vertex[i].z;
}
if (vertex.size()>0){
center.x /= float(vertex.size());
center.y /= float(vertex.size());
center.z /= float(vertex.size());
}
*/
return center;
};
void Item::registerLights(LightManager * lightManager, bool lightingScene)
{
if(lightingScene)
return;
if(mDataBlock->lightOnlyStatic && !mStatic)
return;
F32 intensity;
switch(mDataBlock->lightType)
{
case ConstantLight:
intensity = mFadeVal;
break;
case PulsingLight:
{
S32 delta = Sim::getCurrentTime() - mDropTime;
intensity = 0.5f + 0.5f * mSin(M_PI_F * F32(delta) / F32(mDataBlock->lightTime));
intensity = 0.15f + intensity * 0.85f;
intensity *= mFadeVal; // fade out light on flags
break;
}
default:
return;
}
// Create a light if needed
if (!mLight)
{
mLight = lightManager->createLightInfo();
}
mLight->setColor( mDataBlock->lightColor * intensity );
mLight->setType( LightInfo::Point );
mLight->setRange( mDataBlock->lightRadius );
mLight->setPosition( getBoxCenter() );
lightManager->registerGlobalLight( mLight, this );
}
void SFXEmitter::_renderObject( ObjectRenderInst* ri, SceneRenderState* state, BaseMatInstance* overrideMat )
{
// Check to see if the emitter is in range and playing
// and assign a proper color depending on this.
ColorI color;
if( _getPlaybackStatus() == SFXStatusPlaying )
{
if( isInRange() )
color = smRenderColorPlayingInRange;
else
color = smRenderColorPlayingOutOfRange;
}
else
{
if( isInRange() )
color = smRenderColorStoppedInRange;
else
color = smRenderColorStoppedOutOfRange;
}
// Draw the cube.
GFXStateBlockDesc desc;
desc.setZReadWrite( true, false );
desc.setBlend( true );
desc.setCullMode( GFXCullNone );
GFXDrawUtil *drawer = GFX->getDrawUtil();
drawer->drawCube( desc, Point3F( 0.5f, 0.5f, 0.5f ), getBoxCenter(), color );
// Render visual feedback for 3D sounds.
if( ( smRenderEmitters || isSelected() ) && is3D() )
_render3DVisualFeedback();
}
void Turret::trackAndFire (Player *closePlayer, float interval)
{
if (data->isSustained == false) {
Vector3F rot = getAngulerPosition();
int aimed = 0;
float old_rot = turretRotation;
float increment = data->speed * interval;
float des_z;
Point3F playerPos;
float dist = m_distf (getBoxCenter(), closePlayer->getLeadCenter());
leadPosition (closePlayer->getLeadCenter(), closePlayer->getLeadVelocity(), dist, &playerPos);
TMat3F invMat;
getNodeOffset (&invMat, "dummy muzzle", gunNode);
invMat.inverse();
m_mul (Point3F (playerPos.x, playerPos.y, playerPos.z), invMat, &playerPos);
des_z = rotation (-playerPos.x, -playerPos.y);
while (des_z < 0)
des_z += (float)M_2PI;
while (des_z > M_2PI)
des_z -= (float)M_2PI;
float diff = des_z - turretRotation;
if (diff > M_PI || diff < -M_PI)
increment = -increment;
if (diff < increment && diff > -increment)
{
turretRotation = des_z;
aimed += 1;
}
else
if (diff < 0)
turretRotation -= increment;
else
turretRotation += increment;
wrapRotation ();
if (turretRotation != old_rot)
setMaskBits (TRotationMask);
float old_elevation = turretElevation;
float des_y;
increment = data->speed * interval;
des_y = elevation (playerPos.x, playerPos.y, playerPos.z);
diff = des_y - turretElevation;
if (diff > M_PI || diff < -M_PI)
increment = -increment;
if (diff < increment && diff > -increment)
{
turretElevation = des_y;
aimed += 1;
}
else
if (diff < 0)
turretElevation -= increment;
else
turretElevation += increment;
wrapElevation ();
if (old_elevation != turretElevation)
setMaskBits (ElevationMask);
if (closePlayer && aimed >= 2 && waitTime <= manager->getCurrentTime())
shoot (false, closePlayer);
} else {
Vector3F rot = getAngulerPosition();
int aimed = 0;
float old_rot = turretRotation;
float increment = data->speed * interval;
float des_z;
Point3F playerPos;
float dist = m_distf (getBoxCenter(), closePlayer->getLeadCenter());
leadPosition (closePlayer->getLeadCenter(), closePlayer->getLeadVelocity(), dist, &playerPos);
TMat3F invMat;
getNodeOffset (&invMat, "dummy muzzle", gunNode);
invMat.inverse();
m_mul (Point3F (playerPos.x, playerPos.y, playerPos.z), invMat, &playerPos);
des_z = rotation (-playerPos.x, -playerPos.y);
while (des_z < 0)
des_z += (float)M_2PI;
while (des_z > M_2PI)
des_z -= (float)M_2PI;
float diff = des_z - turretRotation;
if (diff > M_PI || diff < -M_PI)
increment = -increment;
if (diff < increment && diff > -increment)
{
turretRotation = des_z;
aimed += 1;
}
else
if (diff < 0)
turretRotation -= increment;
else
turretRotation += increment;
wrapRotation ();
if (turretRotation != old_rot)
setMaskBits (TRotationMask);
float old_elevation = turretElevation;
float des_y;
increment = data->speed * interval;
des_y = elevation (playerPos.x, playerPos.y, playerPos.z);
diff = des_y - turretElevation;
if (diff > M_PI || diff < -M_PI)
increment = -increment;
if (diff < increment && diff > -increment)
{
turretElevation = des_y;
aimed += 1;
}
else
if (diff < 0)
turretElevation -= increment;
else
turretElevation += increment;
wrapElevation ();
if (old_elevation != turretElevation)
setMaskBits (ElevationMask);
if (closePlayer && aimed >= 2 && waitTime <= manager->getCurrentTime()) {
shoot (false, closePlayer);
}
}
}
void
Turret::serverProcessFiring(DWORD in_currTime)
{
if (!getControlClient() && getState () == StaticBase::Enabled && isActive()) {
AssertFatal(m_pProjectile != NULL, "Must have projectile");
if (m_pTarget == NULL) {
// Lost our target, or player mount just ended...
unshoot();
return;
}
if (in_currTime >= m_beganState + data->firingTime) {
// If the firing time runs out, we switch to reloading...
unshoot();
return;
}
float useRange = data->gunRange == -1 ? data->iRange : data->gunRange;
float minDist = useRange;
if (isTargetable(m_pTarget, &minDist, useRange) == false) {
unshoot();
return;
}
// Guess we're still good, track the player...
float interval = 0.032;
Vector3F rot = getAngulerPosition();
int aimed = 0;
float old_rot = turretRotation;
float increment = data->speed * interval;
float des_z;
Point3F playerPos;
float dist = m_distf (getBoxCenter(), m_pTarget->getLeadCenter());
leadPosition (m_pTarget->getLeadCenter(), m_pTarget->getLeadVelocity(), dist, &playerPos);
TMat3F invMat;
getNodeOffset (&invMat, "dummy muzzle", gunNode);
invMat.inverse();
m_mul (Point3F (playerPos.x, playerPos.y, playerPos.z), invMat, &playerPos);
des_z = rotation (-playerPos.x, -playerPos.y);
while (des_z < 0)
des_z += (float)M_2PI;
while (des_z > M_2PI)
des_z -= (float)M_2PI;
float diff = des_z - turretRotation;
if (diff > M_PI || diff < -M_PI)
increment = -increment;
if (diff < increment && diff > -increment)
{
turretRotation = des_z;
aimed += 1;
}
else
if (diff < 0)
turretRotation -= increment;
else
turretRotation += increment;
wrapRotation ();
if (turretRotation != old_rot)
setMaskBits (TRotationMask);
float old_elevation = turretElevation;
float des_y;
increment = data->speed * interval;
des_y = elevation (playerPos.x, playerPos.y, playerPos.z);
diff = des_y - turretElevation;
if (diff > M_PI || diff < -M_PI)
increment = -increment;
if (diff < increment && diff > -increment)
{
turretElevation = des_y;
aimed += 1;
}
else
if (diff < 0)
turretElevation -= increment;
else
turretElevation += increment;
wrapElevation ();
if (old_elevation != turretElevation)
setMaskBits (ElevationMask);
}
if (m_pProjectile)
m_pProjectile->updateImageTransform(getEyeTransform());
}
bool Player::onSimRenderQueryImage (SimRenderQueryImage* query)
{
// Update our drawShape flag.
// If we're first person and mounted on something:
bool drawShape = true;
if (query->viewportObject) {
// Check to see if we are mounted by the current camera
SimGui::TSControl* vp = dynamic_cast<SimGui::TSControl*>
(query->viewportObject);
GameBase *co = cg.psc->getControlObject();
if (vp && vp->getObject() == cg.psc) {
if(cg.psc->isFirstPerson()) {
// if(mount && (cg.psc->getControlObject() == mount || !mount->mountRender()))
if(mount && co == mount && mountPoint == 1)
return false;
if(cg.psc->getControlObject() == this)
drawShape = false;
}
}
if(co) {
ObserverCamera *oc = dynamic_cast<ObserverCamera *>(co);
if(oc && oc->isEyesView(this))
drawShape = false;
}
}
// Some mounted vehicles don't render the player
if (mount && !mount->mountRender() && mountPoint == 1)
return false;
// Get the image from the base class, this also checks to
// see if the player is within the viewcone.
if (!Parent::onSimRenderQueryImage(query))
return false;
image.drawShape = drawShape;
if (mount)
image.castShadow = false;
// Animate the player
clearAnimTransform();
image.shape->animate();
// Player fading
float fadeFactor = 1.0f;
if (m_fading != NotFading) {
float factor = float(wg->currentTime - m_fadeStarted) / float(csm_fadeLength);
// Bail if we're _really faded...
if (factor > 1.0)
factor = 1.0;
fadeFactor = 1.0 - factor;
}
// Shadow fading and swing down
image.alphaLevel = 0.8f * fadeFactor;
if (image.castShadow) {
SimContainer* pContainer = getContainer();
while (pContainer != NULL) {
if ((pContainer->getType() & SimInteriorObjectType) != 0)
break;
else
pContainer = pContainer->getContainer();
}
if (pContainer != NULL) {
InteriorShape* pItr = dynamic_cast<InteriorShape*>(pContainer);
AssertFatal(pItr != NULL, "Not an interiorshape? Shouldn't happen");
if (pItr->getInstance()->isLinked() == true) {
image.alphaLevel = 0.0f;
} else {
// find the closest bbox face...
const Box3F& itrBox = pItr->getBoundingBox();
Point3F myCenter = getBoxCenter();
ITRGeometry* pGeom = pItr->getInstance()->getHighestGeometry();
AssertFatal(pGeom != NULL, "This doesn't seem possible");
int leafIndex;
if ((leafIndex = pGeom->externalLeaf(myCenter)) == 0) {
leafIndex = pGeom->findLeaf(myCenter);
}
ITRGeometry::BSPLeafWrap leafWrap(pGeom, leafIndex);
int outsideBits = pGeom->getOutsideBits(leafWrap);
if ((outsideBits & ITRGeometry::OutsideMask) == 0) {
image.alphaLevel = 0.0f;
} else {
float minDist = itrBox.fMax.x - myCenter.x;
AssertFatal(minDist > 0.0f, "Um, that's not possible if I'm contained");
if ((itrBox.fMax.y - myCenter.y) < minDist)
minDist = itrBox.fMax.y - myCenter.y;
if ((itrBox.fMax.z - myCenter.z) < minDist)
minDist = itrBox.fMax.z - myCenter.z;
if ((myCenter.x - itrBox.fMin.x) < minDist)
minDist = myCenter.x - itrBox.fMin.x;
if ((myCenter.y - itrBox.fMin.y) < minDist)
minDist = myCenter.y - itrBox.fMin.y;
if ((myCenter.z - itrBox.fMin.z) < minDist)
minDist = myCenter.z - itrBox.fMin.z;
if (minDist < 0.0) {
AssertWarn(0, "That shouldn't happen, minDist < 0");
minDist = 0.0f;
}
if (minDist < 3.0f) {
image.alphaLevel = 0.8f * fadeFactor;
image.swingDown = 0.0f;
} else if (minDist > 15.0f) {
image.alphaLevel = 0.3 * fadeFactor;
image.swingDown = 1.0f;
} else {
image.alphaLevel = 0.3f + 0.5f * (1.0f - ((minDist - 3.0f) / 12.0f)) * fadeFactor;
image.swingDown = (minDist - 3.0f) / 12.0f;
}
}
}
}
}
// Shade based on surface
float sunAttenuation;
ColorF positionalColor;
bool overrideSun = getPositionalColor(positionalColor, sunAttenuation);
updateSunOverride(overrideSun, sunAttenuation, positionalColor);
m_lastSunUpdated = wg->currentTime;
// Mounted items
int i;
for (i = 0; i < MaxItemImages; i++)
if (SimRenderImage* pImage = getImage(i,query->renderContext)) {
query->image[query->count++] = pImage;
FearRenderImage* pFRI = dynamic_cast<FearRenderImage*>(pImage);
if (pFRI != NULL) {
pFRI->shape->setAlphaAlways(image.shape->getAlwaysAlpha(),
image.shape->getAlwaysAlphaValue());
if (image.shape->getAlwaysAlpha()) {
pFRI->sortValue = image.sortValue + 0.01;
pFRI->itype = SimRenderImage::Translucent;
}
}
}
// Jet Image
if (image.drawShape) {
if (jetting && flameImage.shape) {
getMountTransform(JetExhaust,&flameImage.transform);
// Return the image
flameImage.sortValue = image.sortValue + 0.01;
query->image[query->count++] = &flameImage;
}
// Set detail scale for player shapes. Higher for others, here
// take halfway to full - need separate value?
image.shape->setDetailScale( hasFocus ? prefShapeDetail :
((prefShapeDetail + 1.0) / 2.0) );
}
// Haze everything
for(i = 1; i < query->count; i++)
query->image[i]->hazeValue = query->image[0]->hazeValue;
return true;
}
