void CPhysicsObject::Sleep() {
// Static objects can't sleep!
if (IsStatic())
return;
m_pObject->setActivationState(ISLAND_SLEEPING);
}
bool CPhysicsObject::IsGravityEnabled() const {
if (!IsStatic()) {
return !(m_pObject->getFlags() & BT_DISABLE_WORLD_GRAVITY);
}
return false;
}
// This method will grow array's MaxCount. No items will be allocated.
// The allocated memory is not initialized because items could be inserted
// and removed at any time - so initialization should be performed in
// upper level functions like Insert()
void FArray::GrowArray(int count, int elementSize)
{
guard(FArray::GrowArray);
assert(count > 0);
int prevCount = MaxCount;
// check for available space
if (DataCount + count > MaxCount)
{
// not enough space, resize ...
MaxCount = ((DataCount + count + 15) / 16) * 16 + 16;
if (!IsStatic())
{
DataPtr = appRealloc(DataPtr, MaxCount * elementSize);
}
else
{
// "static" array becomes non-static
void* oldData = DataPtr; // this is a static pointer
DataPtr = appMalloc(MaxCount * elementSize);
memcpy(DataPtr, oldData, prevCount * elementSize);
}
}
unguardf("%d x %d", count, elementSize);
}
void AmFilterAddOnHandle::ImageUnloading(image_id image)
{
if (!IsStatic()) {
delete mAddOn;
mAddOn = NULL;
}
}
void MotionMaster::DirectDelete(MovementGenerator* curr)
{
if (IsStatic(curr))
return;
curr->Finalize(_owner);
delete curr;
}
bool CPhysicsObject::IsDragEnabled() const {
if (!IsStatic()) {
return m_pEnv->GetDragController()->IsControlling(this);
}
return false;
}
XBOOL XCatch::StartCatch(CONNECTINFO &req, RESPONSEINFO &info)
{
// return XFALSE;
if(req.URL.m_nProto>=XPROTO_FTP) return XFALSE;
if(info.nMaxAge<=0)
{
if(IsStatic(info.type.m_nClass,info.type.m_nType))
{
int l=req.URL.m_strURL.ReverseFind('?');
if(l<0||info.nLength>64000)
info.nMaxAge=86400*4;
else
return XFALSE;
}
else
return XFALSE;
}
MakeFile(req);
XU8 s=XFile::XWRITE|XFile::XCREATE|XFile::XBINARY;
if(info.nErrorCode==XHTTP_STATUS_NOT_MODIFIED)
s=XFile::XAPPEND|XFile::XCREATE|XFile::XBINARY;
if(!m_file.Open(m_strFile,s)) return XFALSE;
XCHeader hd={{'F','C','T'},req.nMethod,info.nErrorCode,
info.nMaxAge,info.time.GetTime(),
info.type.m_nClass,info.type.m_nCharset,
info.type.m_nType};
if(hd.nErrorCode==XHTTP_STATUS_NOT_MODIFIED)
{
hd.nErrorCode=XHTTP_STATUS_OK;
m_file.Seek(0,XFile::XSEEK_SET);
}
else if(hd.nErrorCode!=XHTTP_STATUS_OK)
hd.nMaxAge=0;
//hd.nErrorCode=XHTTP_STATUS_CREATED;
m_file.Write(&hd,sizeof(hd));
XU8 v=(XU8)info.strCookies.GetSize();
if(v>10) v=10;
m_file.Write(&v,sizeof(v));
XU16 i;
for(i=0;i<v;i++)
m_file.WriteString(info.strCookies[i]);
m_file.WriteString(info.strConfigURL);
m_file.WriteString(info.strFilterURL);
v=info.strResHeaders.GetSize();
m_file.Write(&v,sizeof(v));
for(i=0;i<v;i++)
m_file.WriteString(info.strResHeaders[i]);
//for(XU32 i=0;i<info.strCookies.GetSize();i++)
// m_file.WriteString(info.strCookies[i]);
return XTRUE;
}
void MotionMaster::DelayedDelete(MovementGenerator* curr)
{
TC_LOG_DEBUG("movement.motionmaster", "MotionMaster::DelayedDelete: '%s', delayed deleting movement generator (type: %u)", _owner->GetGUID().ToString().c_str(), curr->GetMovementGeneratorType());
if (IsStatic(curr))
return;
_expireList.push_back(curr);
}
void CPhysicsObject::Wake() {
// Static objects can't wake!
if (IsStatic())
return;
m_pObject->setDeactivationTime(0);
m_pObject->setActivationState(ACTIVE_TAG);
}
bool CPhysicsObject::IsGravityEnabled()
{
if ( !IsStatic() )
{
return IsControlling( m_pObject->get_core()->environment->get_gravity_controller() );
}
return false;
}
bool CPhysicsObject::IsDragEnabled()
{
if ( !IsStatic() )
{
return IsControlling( GetVPhysicsEnvironment()->GetDragController() );
}
return false;
}
void MotionMaster::DelayedDelete(MovementGenerator* curr)
{
TC_LOG_FATAL("misc", "Unit (Entry %u) is trying to delete its updating Movement Generator (Type %u)!", _owner->GetEntry(), curr->GetMovementGeneratorType());
if (IsStatic(curr))
return;
if (!_expireList)
_expireList = new ExpireList();
_expireList->push_back(curr);
}
void CPhysicsObject::OutputDebugInfo() const {
Msg("-----------------\n");
if (m_pName)
Msg("Object: %s\n", m_pName);
Msg("Mass: %f (inv %f)\n", GetMass(), GetInvMass());
Vector pos;
QAngle ang;
GetPosition(&pos, &ang);
Msg("Position: %f %f %f\nAngle: %f %f %f\n", pos.x, pos.y, pos.z, ang.x, ang.y, ang.z);
Vector inertia = GetInertia();
Vector invinertia = GetInvInertia();
Msg("Inertia: %f %f %f (inv %f %f %f)\n", inertia.x, inertia.y, inertia.z, invinertia.x, invinertia.y, invinertia.z);
Vector vel;
AngularImpulse angvel;
GetVelocity(&vel, &angvel);
Msg("Velocity: %f, %f, %f\nAng Velocity: %f, %f, %f\n", vel.x, vel.y, vel.z, angvel.x, angvel.y, angvel.z);
float dampspeed, damprot;
GetDamping(&dampspeed, &damprot);
Msg("Damping %f linear, %f angular\n", dampspeed, damprot);
Vector dragBasis;
Vector angDragBasis;
ConvertPosToHL(m_dragBasis, dragBasis);
ConvertDirectionToHL(m_angDragBasis, angDragBasis);
Msg("Linear Drag: %f, %f, %f (factor %f)\n", dragBasis.x, dragBasis.y, dragBasis.z, m_dragCoefficient);
Msg("Angular Drag: %f, %f, %f (factor %f)\n", angDragBasis.x, angDragBasis.y, angDragBasis.z, m_angDragCoefficient);
// TODO: Attached to x controllers
Msg("State: %s, Collision %s, Motion %s, Drag %s, Flags %04X (game %04x, index %d)\n",
IsAsleep() ? "Asleep" : "Awake",
IsCollisionEnabled() ? "Enabled" : "Disabled",
IsStatic() ? "Static" : IsMotionEnabled() ? "Enabled" : "Disabled",
IsDragEnabled() ? "Enabled" : "Disabled",
m_pObject->getFlags(),
GetGameFlags(),
GetGameIndex()
);
const char *pMaterialStr = g_SurfaceDatabase.GetPropName(m_materialIndex);
surfacedata_t *surfaceData = g_SurfaceDatabase.GetSurfaceData(m_materialIndex);
if (surfaceData) {
Msg("Material: %s : density(%f), thickness(%f), friction(%f), elasticity(%f)\n",
pMaterialStr, surfaceData->physics.density, surfaceData->physics.thickness, surfaceData->physics.friction, surfaceData->physics.elasticity);
}
Msg("-- COLLISION SHAPE INFO --\n");
g_PhysicsCollision.OutputDebugInfo((CPhysCollide *)m_pObject->getCollisionShape()->getUserPointer());
}
void CPhysicsObject::EnableDrag(bool enable) {
if (IsStatic() || enable == IsDragEnabled())
return;
if (enable) {
m_pEnv->GetDragController()->AddPhysicsObject(this);
} else {
m_pEnv->GetDragController()->RemovePhysicsObject(this);
}
}
MotionMaster::~MotionMaster()
{
// clear ALL movement generators (including default)
while (!empty())
{
MovementGenerator *curr = top();
pop();
if (curr && !IsStatic(curr))
delete curr; // Skip finalizing on delete, it might launch new movement
}
}
FArray::~FArray()
{
if (!IsStatic())
{
if (DataPtr)
appFree(DataPtr);
}
DataCount = 0;
DataPtr = NULL;
MaxCount = 0;
}
void CPhysicsObject::EnableGravity(bool enable) {
if (IsGravityEnabled() == enable || IsStatic()) return;
if (enable) {
m_pObject->setGravity(m_pEnv->GetBulletEnvironment()->getGravity());
m_pObject->setFlags(m_pObject->getFlags() & ~BT_DISABLE_WORLD_GRAVITY);
} else {
m_pObject->setGravity(btVector3(0,0,0));
m_pObject->setFlags(m_pObject->getFlags() | BT_DISABLE_WORLD_GRAVITY);
}
}
void CPhysicsObject::EnableMotion(bool enable) {
if (IsMotionEnabled() == enable || IsStatic()) return;
if (enable) {
m_pObject->setFlags(m_pObject->getFlags() & ~(BT_DISABLE_MOTION));
} else {
m_pObject->setLinearVelocity(btVector3(0, 0, 0));
m_pObject->setAngularVelocity(btVector3(0, 0, 0));
m_pObject->setFlags(m_pObject->getFlags() | BT_DISABLE_MOTION);
}
}
void CPhysicsObject::Init(CPhysicsEnvironment* pEnv, btRigidBody* pObject, int materialIndex, float volume, float drag, float angDrag, const Vector *massCenterOverride) {
m_pEnv = pEnv;
m_materialIndex = materialIndex;
m_pObject = pObject;
pObject->setUserPointer(this);
m_pGameData = NULL;
m_gameFlags = 0;
m_iLastActivationState = pObject->getActivationState();
m_callbacks = CALLBACK_GLOBAL_COLLISION|CALLBACK_GLOBAL_FRICTION|CALLBACK_FLUID_TOUCH|CALLBACK_GLOBAL_TOUCH|CALLBACK_GLOBAL_COLLIDE_STATIC|CALLBACK_DO_FLUID_SIMULATION;
m_fVolume = volume;
float matdensity;
g_SurfaceDatabase.GetPhysicsProperties(materialIndex, &matdensity, NULL, NULL, NULL);
m_fBuoyancyRatio = (GetMass()/(GetVolume()*METERS_PER_INCH*METERS_PER_INCH*METERS_PER_INCH))/matdensity;
surfacedata_t *surface = g_SurfaceDatabase.GetSurfaceData(materialIndex);
if (surface)
{
m_pObject->setFriction(surface->physics.friction);
// Note to self: using these dampening values = breakdancing fridges http://dl.dropbox.com/u/4838268/gm_construct%202012-4-24%2004-50-26.webm
//m_pObject->setDamping(surface->physics.dampening, surface->physics.dampening);
}
// Drag calculations converted from 2003 source code
if (!IsStatic() && GetCollide() )
{
btCollisionShape * shape = m_pObject->getCollisionShape();
btVector3 min, max, delta;
btTransform t;
delta = min, max;
delta = delta.absolute();
shape->getAabb( t, min, max);
m_dragBasis.setX(delta.y() * delta.z());
m_dragBasis.setY(delta.x() * delta.z());
m_dragBasis.setZ(delta.x() * delta.y());
btVector3 ang = m_pObject->getInvInertiaDiagLocal();
delta *= 0.5;
m_angDragBasis.setX(AngDragIntegral( ang[0], delta.x(), delta.y(), delta.z() ) + AngDragIntegral( ang[0], delta.x(), delta.z(), delta.y() ));
m_angDragBasis.setY(AngDragIntegral( ang[1], delta.y(), delta.x(), delta.z() ) + AngDragIntegral( ang[1], delta.y(), delta.z(), delta.x() ));
m_angDragBasis.setZ(AngDragIntegral( ang[2], delta.z(), delta.x(), delta.y() ) + AngDragIntegral( ang[2], delta.z(), delta.y(), delta.x() ));
} else {
drag = 0;
angDrag = 0;
}
m_dragCoefficient = drag;
m_angDragCoefficient = angDrag;
}
void CSceneObject::OnFrame()
{
inherited::OnFrame();
if (!m_pReference) return;
if (m_pReference) m_pReference->OnFrame();
if (psDeviceFlags.is(rsStatistic)){
if (IsStatic()||IsMUStatic()||Selected()){
Device.Statistic->dwLevelSelFaceCount += GetFaceCount();
Device.Statistic->dwLevelSelVertexCount += GetVertexCount();
}
}
}
bool ETHRenderEntity::DrawAmbientPass(const float maxHeight, const float minHeight,
const bool enableLightmaps, const ETHSceneProperties& sceneProps,
const float parallaxIntensity)
{
if (!m_pSprite || IsHidden())
return false;
Vector4 v4FinalAmbient = Vector4(sceneProps.ambient, 1.0f);
v4FinalAmbient.x = Min(1.0f, v4FinalAmbient.x + m_properties.emissiveColor.x);
v4FinalAmbient.y = Min(1.0f, v4FinalAmbient.y + m_properties.emissiveColor.y);
v4FinalAmbient.z = Min(1.0f, v4FinalAmbient.z + m_properties.emissiveColor.z);
v4FinalAmbient = v4FinalAmbient * m_v4Color;
SetDepth(maxHeight, minHeight);
const VideoPtr& video = m_provider->GetVideo();
const bool applyLightmap = (m_pLightmap && enableLightmaps && IsStatic());
if (applyLightmap)
{
m_pLightmap->SetAsTexture(1);
}
// sets the alpha mode according to the entity's property
const Video::ALPHA_MODE& am = GetBlendMode();
if (am != video->GetAlphaMode())
video->SetAlphaMode(am);
ValidateSpriteCut(m_pSprite);
m_pSprite->SetRect(m_spriteFrame);
SetOrigin();
const bool shouldUseFourTriangles = ShouldUseFourTriangles(parallaxIntensity);
const float angle = (m_properties.type == ETHEntityProperties::ET_VERTICAL) ? 0.0f : GetAngle();
const Vector2 pos = ETHGlobal::ToScreenPos(GetPosition(), sceneProps.zAxisDirection);
if (shouldUseFourTriangles)
m_pSprite->SetRectMode(Sprite::RM_FOUR_TRIANGLES);
m_pSprite->DrawOptimal(pos, ConvertToDW(v4FinalAmbient), angle, GetCurrentSize());
if (shouldUseFourTriangles)
m_pSprite->SetRectMode(Sprite::RM_TWO_TRIANGLES);
if (applyLightmap)
{
video->UnsetTexture(1);
}
return true;
}
// called from code:MethodTableBuilder::InitializeFieldDescs#InitCall
VOID FieldDesc::Init(mdFieldDef mb, CorElementType FieldType, DWORD dwMemberAttrs, BOOL fIsStatic, BOOL fIsRVA, BOOL fIsThreadLocal, BOOL fIsContextLocal, LPCSTR pszFieldName)
{
LIMITED_METHOD_CONTRACT;
// We allow only a subset of field types here - all objects must be set to TYPE_CLASS
// By-value classes are ELEMENT_TYPE_VALUETYPE
_ASSERTE(
FieldType == ELEMENT_TYPE_I1 ||
FieldType == ELEMENT_TYPE_BOOLEAN ||
FieldType == ELEMENT_TYPE_U1 ||
FieldType == ELEMENT_TYPE_I2 ||
FieldType == ELEMENT_TYPE_U2 ||
FieldType == ELEMENT_TYPE_CHAR ||
FieldType == ELEMENT_TYPE_I4 ||
FieldType == ELEMENT_TYPE_U4 ||
FieldType == ELEMENT_TYPE_I8 ||
FieldType == ELEMENT_TYPE_I ||
FieldType == ELEMENT_TYPE_U ||
FieldType == ELEMENT_TYPE_U8 ||
FieldType == ELEMENT_TYPE_R4 ||
FieldType == ELEMENT_TYPE_R8 ||
FieldType == ELEMENT_TYPE_CLASS ||
FieldType == ELEMENT_TYPE_VALUETYPE ||
FieldType == ELEMENT_TYPE_PTR ||
FieldType == ELEMENT_TYPE_FNPTR
);
_ASSERTE(fIsStatic || (!fIsRVA && !fIsThreadLocal && !fIsContextLocal));
_ASSERTE(fIsRVA + fIsThreadLocal + fIsContextLocal <= 1);
m_requiresFullMbValue = 0;
SetMemberDef(mb);
m_type = FieldType;
m_prot = fdFieldAccessMask & dwMemberAttrs;
m_isStatic = fIsStatic != 0;
m_isRVA = fIsRVA != 0;
m_isThreadLocal = fIsThreadLocal != 0;
#ifdef _DEBUG
m_debugName = (LPUTF8)pszFieldName;
#endif
#if CHECK_APP_DOMAIN_LEAKS
m_isDangerousAppDomainAgileField = 0;
#endif
_ASSERTE(GetMemberDef() == mb); // no truncation
_ASSERTE(GetFieldType() == FieldType);
_ASSERTE(GetFieldProtection() == (fdFieldAccessMask & dwMemberAttrs));
_ASSERTE((BOOL) IsStatic() == (fIsStatic != 0));
}
void AmFilterAddOnHandle::ImageLoaded(image_id image)
{
if (!IsStatic()) {
ImageUnloading(image);
void *factory;
status_t err = get_image_symbol(image, "make_nth_filter",
B_SYMBOL_TYPE_TEXT, &factory);
if (err >= B_OK) {
mAddOn = (*((make_nth_filter_type)factory))(0, image, this, 0);
if (!mAddOn) err = B_ERROR;
}
}
}
void CPhysicsObject::SetMass(float mass) {
if (IsStatic()) return;
m_fMass = mass;
btVector3 inertia = m_pObject->getInvInertiaDiagLocal();
// Inverse the inverse to get the not inverse (unless in the case that the not inverse is inverse, therefore you must inverse the universe)
inertia.setX(SAFE_DIVIDE(1.0f, inertia.x()));
inertia.setY(SAFE_DIVIDE(1.0f, inertia.y()));
inertia.setZ(SAFE_DIVIDE(1.0f, inertia.z()));
m_pObject->setMassProps(mass, inertia);
}
XU8 XCatch::DetectFile(XPCTSTR strFile,XU32&l,XTime&time,XU8 bForward,bool&bStatic)
{
//XTime time;
{
l=0;
if(!m_file.Open(strFile,XFile::XREAD|XFile::XBINARY))
{
XFile::RemoveFile(strFile);
return XC_REMOVE;
}
XCHeader hd;
if(m_file.Read(&hd,sizeof(hd))!=sizeof(hd)||
hd.strMark[0]!='J'||
hd.strMark[1]!='C'||
hd.strMark[2]!='T')
{
m_file.Close();
XFile::RemoveFile(strFile);
return XC_REMOVE;
}
l=m_file.GetLength();
time=hd.nTime;
m_file.Close();
bStatic=IsStatic(hd.nClass,hd.nType);
if(bForward==XCT_CONNECT)
{
if(hd.nErrorCode!=XHTTP_STATUS_OK)
{
XFile::RemoveFile(strFile);
return XC_REMOVE;
}
XTime t(hd.nTime);
//XString8 str;
//t.GetTime(str);
t+=hd.nMaxAge;
XTime t1;
t1.SetCurrentTime();
//t.GetTime(str);
//t1.GetTime(str);
if(t<t1) return XC_OUTOFAGE;
}
}
return XC_OK;
}
/*
============
idStr::FreeData
============
*/
void idStr::FreeData()
{
if( IsStatic() )
{
return;
}
if( data && data != baseBuffer )
{
#ifdef USE_STRING_DATA_ALLOCATOR
stringDataAllocator.Free( data );
#else
delete[] data;
#endif
data = baseBuffer;
}
}
MotionMaster::~MotionMaster()
{
// clear ALL movement generators (including default)
while (!empty())
{
MovementGenerator* movement = top();
pop();
if (movement && !IsStatic(movement))
delete movement;
}
while (!_expireList.empty())
{
delete _expireList.back();
_expireList.pop_back();
}
}
cpBody* RigidBody2D::Create(float mass, float moment)
{
cpBody* handle;
if (IsKinematic())
{
if (IsStatic())
handle = cpBodyNewStatic();
else
handle = cpBodyNewKinematic();
}
else
handle = cpBodyNew(mass, moment);
cpBodySetUserData(handle, this);
return handle;
}
void RigidBody::integrateVelocities(SimdScalar step)
{
if (IsStatic())
return;
m_linearVelocity += m_totalForce * (m_inverseMass * step);
m_angularVelocity += m_invInertiaTensorWorld * m_totalTorque * step;
#define MAX_ANGVEL SIMD_HALF_PI
/// clamp angular velocity. collision calculations will fail on higher angular velocities
float angvel = m_angularVelocity.length();
if (angvel*step > MAX_ANGVEL)
{
m_angularVelocity *= (MAX_ANGVEL/step) /angvel;
}
clearForces();
}
void RigidBody::applyForces(SimdScalar step)
{
if (IsStatic())
return;
applyCentralForce(m_gravity);
m_linearVelocity *= GEN_clamped((1.f - step * gLinearAirDamping * m_linearDamping), 0.0f, 1.0f);
m_angularVelocity *= GEN_clamped((1.f - step * m_angularDamping), 0.0f, 1.0f);
#define FORCE_VELOCITY_DAMPING 1
#ifdef FORCE_VELOCITY_DAMPING
float speed = m_linearVelocity.length();
if (speed < m_linearDamping)
{
float dampVel = 0.005f;
if (speed > dampVel)
{
SimdVector3 dir = m_linearVelocity.normalized();
m_linearVelocity -= dir * dampVel;
} else
{
m_linearVelocity.setValue(0.f,0.f,0.f);
}
}
float angSpeed = m_angularVelocity.length();
if (angSpeed < m_angularDamping)
{
float angDampVel = 0.005f;
if (angSpeed > angDampVel)
{
SimdVector3 dir = m_angularVelocity.normalized();
m_angularVelocity -= dir * angDampVel;
} else
{
m_angularVelocity.setValue(0.f,0.f,0.f);
}
}
#endif //FORCE_VELOCITY_DAMPING
}
