bool gkMouseSensor::query(void)
{
if (m_type == MOUSE_NILL)
return false;
gkMouse* mse = gkWindowSystem::getSingleton().getMouse();
switch (m_type)
{
case MOUSE_LEFT:
return mse->isButtonDown(gkMouse::Left);
case MOUSE_MIDDLE:
return mse->isButtonDown(gkMouse::Middle);
case MOUSE_RIGHT:
return mse->isButtonDown(gkMouse::Right);
case MOUSE_MOTION:
return mse->moved;
case MOUSE_WHEEL_UP:
return mse->wheelDelta > 0;
case MOUSE_WHEEL_DOWN:
return mse->wheelDelta < 0;
case MOUSE_MOUSE_OVER:
case MOUSE_MOUSE_OVER_ANY:
// use Ogre viewport to ray query
if (m_last && !mse->moved)
return m_last;
m_last = rayTest();
return m_last;
}
return false;
}
bool PhysicEngine::isAnyActorStandingOn (const std::string& objectName)
{
for (PhysicActorContainer::iterator it = mActorMap.begin(); it != mActorMap.end(); ++it)
{
if (!it->second->getOnGround())
continue;
Ogre::Vector3 pos = it->second->getPosition();
btVector3 from (pos.x, pos.y, pos.z);
btVector3 to = from - btVector3(0,0,5);
std::pair<std::string, float> result = rayTest(from, to);
if (result.first == objectName)
return true;
}
return false;
}
bool gkMouseSensor::query(void)
{
if (m_type == MOUSE_NILL)
return false;
gkMouse* mse = gkWindowSystem::getSingleton().getMouse();
switch (m_type)
{
case MOUSE_LEFT:
return mse->isButtonDown(gkMouse::Left);
case MOUSE_MIDDLE:
return mse->isButtonDown(gkMouse::Middle);
case MOUSE_RIGHT:
return mse->isButtonDown(gkMouse::Right);
case MOUSE_MOTION:
return mse->moved;
case MOUSE_WHEEL_UP:
return mse->wheelDelta > 0;
case MOUSE_WHEEL_DOWN:
return mse->wheelDelta < 0;
case MOUSE_MOUSE_OVER:
case MOUSE_MOUSE_OVER_ANY:
#if GK_PLATFORM == GK_PLATFORM_ANDROID || GK_PLATFORM == GK_PLATFORM_APPLE_IOS
// the ray-cast make on a mobile device only sense when the device is touched.
// this should work as long as the mouse-touch is mapped to left-click
if (!mse->isButtonDown(gkMouse::Left))
return false;
#endif
// use Ogre viewport to ray query. Since moveable objects might move under the
// mouse the raytest have to be done every tick.
m_lastResult = rayTest();
return m_lastResult;
}
return false;
}
bool DynamicsWorld::castRay(
const btVector3 & origin,
const btVector3 & direction,
const btScalar length,
const btCollisionObject * caster,
COLLISION_CONTACT & contact) const
{
btVector3 p = origin + direction * length;
btVector3 n = -direction;
btScalar d = length;
int patch_id = -1;
const BEZIER * b = 0;
const TRACKSURFACE * s = TRACKSURFACE::None();
btCollisionObject * c = 0;
MyRayResultCallback ray(origin, p, caster);
rayTest(origin, p, ray);
// track geometry collision
bool geometryHit = ray.hasHit();
if (geometryHit)
{
p = ray.m_hitPointWorld;
n = ray.m_hitNormalWorld;
d = ray.m_closestHitFraction * length;
c = ray.m_collisionObject;
if (c->isStaticObject())
{
TRACKSURFACE* tsc = static_cast<TRACKSURFACE*>(c->getUserPointer());
const std::vector<TRACKSURFACE> & surfaces = track->GetSurfaces();
if (tsc >= &surfaces[0] && tsc <= &surfaces[surfaces.size()-1])
{
s = tsc;
}
#ifndef EXTBULLET
else if (c->getCollisionShape()->isCompound())
{
TRACKSURFACE* tss = static_cast<TRACKSURFACE*>(ray.m_shape->getUserPointer());
if (tss >= &surfaces[0] && tss <= &surfaces[surfaces.size()-1])
{
s = tss;
}
}
#endif
//std::cerr << "static object without surface" << std::endl;
}
// track bezierpatch collision
if (track)
{
MATHVECTOR<float, 3> bezierspace_raystart(origin[1], origin[2], origin[0]);
MATHVECTOR<float, 3> bezierspace_dir(direction[1], direction[2], direction[0]);
MATHVECTOR<float, 3> colpoint;
MATHVECTOR<float, 3> colnormal;
patch_id = contact.GetPatchId();
if (track->CastRay(bezierspace_raystart, bezierspace_dir, length,
patch_id, colpoint, b, colnormal))
{
p = btVector3(colpoint[2], colpoint[0], colpoint[1]);
n = btVector3(colnormal[2], colnormal[0], colnormal[1]);
d = (colpoint - bezierspace_raystart).Magnitude();
}
}
contact = COLLISION_CONTACT(p, n, d, patch_id, b, s, c);
return true;
}
// should only happen on vehicle rollover
contact = COLLISION_CONTACT(p, n, d, patch_id, b, s, c);
return false;
}
bool DynamicsWorld::castRay(
const btVector3 & origin,
const btVector3 & direction,
const btScalar length,
const btCollisionObject * caster,
CollisionContact & contact) const
{
btVector3 p = origin + direction * length;
btVector3 n = -direction;
btScalar d = length;
int patch_id = -1;
const Bezier * b = 0;
const TrackSurface * s = TrackSurface::None();
const btCollisionObject * c = 0;
MyRayResultCallback ray(origin, p, caster);
rayTest(origin, p, ray);
// track geometry collision
if (ray.hasHit())
{
p = ray.m_hitPointWorld;
n = ray.m_hitNormalWorld;
d = ray.m_closestHitFraction * length;
c = ray.m_collisionObject;
if (c->isStaticObject())
{
TrackSurface * ts = static_cast<TrackSurface*>(c->getUserPointer());
if (c->getCollisionShape()->isCompound())
ts = static_cast<TrackSurface*>(ray.m_shape->getUserPointer());
// verify surface pointer
if (track)
{
const std::vector<TrackSurface> & surfaces = track->GetSurfaces();
if (ts < &surfaces[0] || ts > &surfaces[surfaces.size() - 1])
ts = NULL;
assert(ts);
}
if (ts)
s = ts;
}
// track bezierpatch collision
if (track)
{
Vec3 org = ToMathVector<float>(origin);
Vec3 dir = ToMathVector<float>(direction);
Vec3 colpoint;
Vec3 colnormal;
patch_id = contact.GetPatchId();
if (track->CastRay(org, dir, length, patch_id, colpoint, b, colnormal))
{
p = ToBulletVector(colpoint);
n = ToBulletVector(colnormal);
d = (colpoint - org).Magnitude();
}
}
contact = CollisionContact(p, n, d, patch_id, b, s, c);
return true;
}
// should only happen on vehicle rollover
contact = CollisionContact(p, n, d, patch_id, b, s, c);
return false;
}
