bool gkRayTest::collides(const gkVector3& from, const gkVector3& to,
gkRayTest::gkRayTestFilter& rayCallback)
{
btVector3 rayFrom(from.x, from.y, from.z);
btVector3 rayTo(to.x, to.y, to.z);
btVector3 hitPointWorld;
rayCallback.m_collisionFilterGroup = btBroadphaseProxy::AllFilter;
rayCallback.m_collisionFilterMask = btBroadphaseProxy::AllFilter;
GK_ASSERT(m_scene);
btDynamicsWorld* pWorld = m_scene->getDynamicsWorld()->getBulletWorld();
GK_ASSERT(pWorld);
pWorld->rayTest(rayFrom, rayTo, rayCallback);
if (rayCallback.hasHit())
{
m_hitNormalWorld = gkVector3(rayCallback.m_hitNormalWorld);
m_collisionObject = rayCallback.m_collisionObject;
m_hitFraction = rayCallback.m_closestHitFraction;
hitPointWorld.setInterpolate3(rayFrom, rayTo, m_hitFraction);
m_hitPointWorld = gkVector3(hitPointWorld);
return true;
}
return false;
}
void gkBlenderSceneConverter::convertObjectGeneral(gkGameObject* gobj, Blender::Object* bobj)
{
gkQuaternion quat;
gkVector3 loc, scale;
gkMatrix4 obmat = gkMathUtils::getFromFloat(bobj->obmat);
gkMathUtils::extractTransform(obmat, loc, quat, scale);
// prevent zero scale
gkVector3 scaleTest = gkVector3(bobj->size[0], bobj->size[1], bobj->size[2]);
if (scaleTest.isZeroLength())
scale = gkVector3(1.f, 1.f, 1.f);
gkGameObjectProperties& props = gobj->getProperties();
if (bobj->parent && validObject(bobj->parent)) {
props.m_parent = GKB_IDNAME(bobj->parent);
if ( bobj->parent->type==OB_ARMATURE){
gkString parentBoneName(bobj->parsubstr);
if (!parentBoneName.empty()){
props.m_boneParent = parentBoneName;
}
}
}
props.m_transform = gkTransformState(loc, quat, scale);
if (bobj->restrictflag & OB_RESTRICT_RENDER)
props.m_mode |= GK_INVISIBLE;
gobj->setActiveLayer((m_bscene->lay & bobj->lay) != 0);
gobj->setLayer((UTuint32)bobj->lay);
}
void gkPhysicsDebug::drawLine(const btVector3& from, const btVector3& to, const btVector3& color)
{
gkDebugger* dbg = m_physics->getScene()->getDebugger();
if (dbg)
dbg->drawLine(gkVector3(from.x(), from.y(), from.z()), gkVector3(to.x(), to.y(), to.z()), gkVector3(color.x(), color.y(), color.z()));
}
void gkDefaultController::moveCamera(void)
{
gkGamePlayer::Data& data = m_player->getData();
if (m_mouse->mouseMoved())
{
const gkScalar tick = gkAppData::gkFixedTickDelta * .25f;
if (m_mouse->relative.x!= 0.f)
data.m_zRot->roll(-gkRadian(m_mouse->relative.x * tick));
if (m_mouse->relative.y!= 0.f)
data.m_xRot->pitch(-gkRadian(m_mouse->relative.y * tick));
}
else
{
// Auto rebound pitch.
gkScalar cPitch = data.m_xRot->getRotation().x.valueRadians();
cPitch = -gkAppData::gkJoyReboundFac * cPitch;
data.m_xRot->pitch(gkDegree(cPitch));
}
data.m_zRot->translate(
(data.m_physics->getPosition() - (data.m_zRot->getPosition() +
gkVector3(0, 0, -gkAppData::gkPlayerHeadZ))
) * gkAppData::gkCameraTol
);
}
void gkJoystickController::movePlayer(void)
{
gkGamePlayer::Data& data = m_player->getData();
gkScalar axRotLR = (m_movement.m_normal.y * gkPi);
gkScalar axRotUD = (-m_movement.m_normal.x * gkPi);
gkScalar axTan = -gkMath::ATan2(axRotLR, axRotUD).valueDegrees();
gkScalar speed = 3.f;
if (m_movement.isInFactor(gkAppData::gkJoyWalkToRunTol))
speed /= 4.f;
gkScalar axLinUD = speed * -m_movement.m_normal.x;
gkScalar axLinLR = speed * m_movement.m_normal.y;
gkVector3 linvel = data.m_physics->getLinearVelocity();
gkQuaternion curZRot = data.m_zRot->getOrientation();
gkQuaternion aOri = gkEuler(0.f, 0.f, axTan).toQuaternion();
aOri.normalise();
gkVector3 m = curZRot * gkVector3(axLinLR, axLinUD, linvel.z);
data.m_physics->setLinearVelocity(m);
data.m_entity->setOrientation(aOri * curZRot);
}
void gkJoystickController::moveCamera(void)
{
gkGamePlayer::Data& data = m_player->getData();
gkScalar crAxUD = (m_camRot.m_normal.x * gkPih) * gkAppData::gkFixedTickDelta2;
gkScalar crAxLR = (m_camRot.m_normal.y * gkPih) * gkAppData::gkFixedTickDelta2;
data.m_xRot->pitch(gkRadian(crAxUD));
if (m_camRot.isDeadUD())
{
// Auto rebound pitch.
gkScalar cPitch = data.m_xRot->getRotation().x.valueRadians();
cPitch = -gkAppData::gkJoyReboundFac * cPitch;
data.m_xRot->pitch(gkDegree(cPitch));
}
if (!m_camRot.isDeadLR())
data.m_zRot->roll(gkRadian(crAxLR));
data.m_zRot->translate(
(data.m_physics->getPosition() - (data.m_zRot->getPosition() +
gkVector3(0, 0, -gkAppData::gkPlayerHeadZ))
) * gkAppData::gkCameraTol
);
}
void gkCollisionNode::update(gkScalar tick)
{
SET_SOCKET_VALUE(HAS_COLLIDED, false);
if (m_timer.getTimeMilliseconds() > 300)
{
SET_SOCKET_VALUE(NOT_HAS_COLLIDED, true);
m_timer.reset();
}
if (GET_SOCKET_VALUE(ENABLE))
{
#ifdef OGREKIT_USE_PHYSICS
m_object->enableContactProcessing(true);
gkContactInfo c;
if (m_object->collidesWith(GET_SOCKET_VALUE(COLLIDES_WITH), &c))
{
SET_SOCKET_VALUE(CONTACT_POSITION, gkVector3(c.point.getPositionWorldOnA()));
SET_SOCKET_VALUE(COLLIDED_OBJ, c.collider->getObject());
SET_SOCKET_VALUE(HAS_COLLIDED, true);
SET_SOCKET_VALUE(NOT_HAS_COLLIDED, false);
m_timer.reset();
}
#endif
}
else
{
#ifdef OGREKIT_USE_PHYSICS
m_object->enableContactProcessing(false);
#endif
}
}
void gkLogic::createVehicle()
{
m_vehicle = new gkBuggy(m_scene);
m_vehicle->load();
m_vehicle->createVehicle();
// Move to start line
m_vehicle->setTransform(gkTransformState(gkVector3(-66.5, 295, -8.5), gkEuler(0, 0, 180).toQuaternion()));
float steerTime = 0.15f;
//simple node setup for logic
m_vehicleNode = m_tree->createNode<gkVehicleNode>();
m_vehicleNode->setVehicle(m_vehicle);
m_vehicleNode->getFRONT()->link(m_upKeyNode->getIS_DOWN());
m_vehicleNode->getREAR()->link(m_downKeyNode->getIS_DOWN());
m_vehicleNode->getLEFT()->link(m_leftKeyNode->getIS_DOWN());
m_vehicleNode->getRIGHT()->link(m_rightKeyNode->getIS_DOWN());
m_vehicleNode->getSTEER_TIME()->setValue(steerTime);
m_vehicleNode->getHAND_BRAKE()->link(m_spaceKeyNode->getIS_DOWN());
m_vehicleNode->getGEAR_UP()->link(m_dKeyNode->getIS_DOWN());
m_vehicleNode->getGEAR_DOWN()->link(m_cKeyNode->getIS_DOWN());
}
AaAppsViewImpl::AaAppsViewImpl():m_AaAppsView(NULL),m_sortType(ST_NAME),m_pViewUtil(NULL)
{
m_ParentRawPos = gkVector3(0,0,0);
m_pViewUtil = AppsViewUtil::getInstance();
if(!pAppTextureUnit)
pAppTextureUnit = new AppUnit::AppTextureUnit();
}
void gkParticleConverter::convertParticle(Blender::ParticleSettings* pt)
{
if (!pt || !pt->effector_weights)
return;
if (pt->ren_as == PART_DRAW_NOT)
return;
Blender::EffectorWeights* wt = pt->effector_weights;
gkParticleSettingsProperties pp;
pp.m_phyType = pt->phystype;
pp.m_name = GKB_IDNAME(pt);
pp.m_emitfrom = pt->from;
pp.m_amount = pt->totpart;
pp.m_lifetime = pt->lifetime/m_fps;
pp.m_start = pt->sta/m_fps;
pp.m_end = pt->end/m_fps;
pp.m_random = pt->randlife;
pp.m_jitter = pt->jitfac;
pp.m_velocity = gkVector3(pt->ob_vel[0], pt->ob_vel[1], pt->ob_vel[2])*10;
pp.m_velNormal = pt->normfac;
pp.m_velTanget = pt->tanfac;
pp.m_size = pt->size*10;
pp.m_mass = pt->mass;
pp.m_sizeRandom = pt->randsize;
pp.m_gravity = wt->global_gravity;
pp.m_trailCount = pt->trail_count;
pp.m_drawEmitter = (pt->draw & 0x8) != 0;
pp.m_material = pt->omat - 1;
if (pt->ren_as == PART_DRAW_HALO)
pp.m_render = gkParticleSettingsProperties::R_HALO;
else if (pt->ren_as == PART_DRAW_BB)
pp.m_render = gkParticleSettingsProperties::R_BILLBOARD;
else if (pt->ren_as == PART_DRAW_OB)
pp.m_render = gkParticleSettingsProperties::R_OBJECT;
else if (pt->ren_as == PART_DRAW_GR)
pp.m_render = gkParticleSettingsProperties::R_GROUP;
else if (pt->ren_as == PART_DRAW_LINE)
pp.m_render = gkParticleSettingsProperties::R_LINE;
else if (pt->ren_as == PART_DRAW_PATH)
pp.m_render = gkParticleSettingsProperties::R_PATH;
//else if (pt->ren_as == PART_DRAW_NOT)
// pp.m_render = gkParticleSettingsProperties::R_NONE;
gkParticleManager::getSingleton().createParticle(gkResourceName(pp.m_name, m_groupName), pp);
}
void gkBlenderSceneConverter::convertWorld(void)
{
if (!m_gscene)
return;
gkSceneProperties& sprops = m_gscene->getProperties();
gkSceneMaterial& props = sprops.m_material;
if (m_bscene->world)
{
Blender::World* world = m_bscene->world;
sprops.m_gravity = gkVector3(0.f, 0.f, -world->gravity);
props.m_ambient.r = world->ambr;
props.m_ambient.g = world->ambg;
props.m_ambient.b = world->ambb;
props.m_horizon.r = world->horr;
props.m_horizon.g = world->horg;
props.m_horizon.b = world->horb;
props.m_zenith.r = world->zenr;
props.m_zenith.g = world->zeng;
props.m_zenith.b = world->zenb;
props.m_name = GKB_IDNAME(world);
// take half far distance of the main camera
props.m_distance = (m_bscene->camera && m_bscene->camera->type == OB_CAMERA ?
((Blender::Camera*)m_bscene->camera->data)->clipend * 0.5f : 10000.f);
if ((world->skytype & WO_SKYBLEND) || (world->skytype & WO_SKYREAL))
{
props.m_type = (world->skytype & WO_SKYBLEND) ? gkSceneMaterial::LINEAR : gkSceneMaterial::REFLECTED;
}
if (world->mode & WO_MIST)
{
sprops.m_fog.m_mode = world->mistype == 0 ? gkFogParams::FM_QUAD :
world->mistype == 1 ? gkFogParams::FM_LIN :
gkFogParams::FM_EXP;
sprops.m_fog.m_start = world->miststa;
sprops.m_fog.m_end = sprops.m_fog.m_start + world->mistdist;
sprops.m_fog.m_intensity = world->misi;
sprops.m_fog.m_color = props.m_horizon;
if ((world->skytype & WO_SKYBLEND))
{
gkVector3 a(world->horr, world->horg, world->horb), b(world->zenr, world->zeng, world->zenb);
gkVector3 c = gkMathUtils::interp(a, b, 0.5);
sprops.m_fog.m_color.r = c.x;
sprops.m_fog.m_color.g = c.y;
sprops.m_fog.m_color.b = c.z;
}
}
}
}
bool gkGamePlayer::groundTest(void)
{
gkScene* scene = m_physics->getOwner();
gkDynamicsWorld* dyn = scene->getDynamicsWorld();
btDynamicsWorld* btw = dyn->getBulletWorld();
const gkScalar range = gkAppData::gkPlayerHeadZ;
const gkScalar angle = range * gkMath::Tan(22.5f);
const gkVector3 vec = m_physics->getPosition();
const gkQuaternion ori = m_physics->getOrientation();
const gkVector3 dir = gkVector3(0, 0, -gkAppData::gkPlayerHeadZ / 2.f);
btTransform btt;
btt.setIdentity();
btt.setOrigin(btVector3(vec.x + dir.x, vec.y + dir.y, vec.z + dir.z));
gkAllContactResultCallback exec;
btConeShapeZ btcs(angle, range);
btCollisionObject btco;
btco.setCollisionShape(&btcs);
btco.setWorldTransform(btt);
btw->contactTest( &btco, exec );
if (btw->getDebugDrawer())
btw->debugDrawObject(btt, &btcs, btVector3(0.f, 1.f, 0.f));
if (!exec.hasHit())
return false;
if (!exec.m_contactObjects.empty())
exec.m_contactObjects.erase(m_physics->getCollisionObject());
if (!exec.m_contactObjects.empty())
{
utArray<const btCollisionObject*>::ConstIterator cit = exec.m_contactObjects.iterator();
while (cit.hasMoreElements())
{
gkGameObject* ob = gkPhysicsController::castObject(cit.getNext());
if (gkPhysicsController::sensorTest(ob, "Floor", "", true) ||
gkPhysicsController::sensorTest(ob, "Crate", "", true))
{
return true;
}
}
}
return false;
}
bool gkRaySensor::query(void)
{
gkVector3 dir;
switch (m_axis)
{
case RA_XPOS: {dir = gkVector3(m_range, 0, 0); break;}
case RA_YPOS: {dir = gkVector3(0, m_range, 0); break;}
case RA_ZPOS: {dir = gkVector3(0, 0, m_range); break;}
case RA_XNEG: {dir = gkVector3(-m_range, 0, 0); break;}
case RA_YNEG: {dir = gkVector3(0, -m_range, 0); break;}
case RA_ZNEG: {dir = gkVector3(0, 0, -m_range); break;}
}
gkRayTest test;
if (test.collides(gkRay(m_object->getWorldPosition(), dir)))
{
gkGameObject* hit = gkPhysicsController::castObject(test.getCollisionObject());
if (hit && hit != m_object)
{
bool onlyActorTODO = false;
return gkPhysicsController::sensorTest(hit, m_prop, m_material, onlyActorTODO);
}
}
return false;
}
void gkDefaultController::movePlayer(void)
{
gkGamePlayer::Data& data = m_player->getData();
gkScalar speed = 3.f;
if(data.m_zRot)
{
gkVector3 movement = data.m_zRot->getOrientation() * gkVector3(0, speed, 0);
data.m_entity->setOrientation(gkEuler(0, 0, data.m_zRot->getRotation().z.valueDegrees()));
movement.z = data.m_physics->getLinearVelocity().z;
data.m_physics->setLinearVelocity(movement);
}
}
void gkSkeletonConverter::buildBoneTree(Blender::Bone* cur, Blender::Bone* prev, gkBone* parent)
{
// This is the normal resposition
GK_ASSERT(cur);
GK_ASSERT(m_skeleton);
gkMatrix4 parBind = gkMatrix4::IDENTITY;
if (prev != 0 && parent != 0)
parBind = gkMathUtils::getFromFloatNorm(prev->arm_mat).inverse();
// create the ogre bone
gkBone* bone = m_skeleton->createBone(cur->name);
if (parent)
bone->setParent(parent);
gkMatrix4 bind = parBind * gkMathUtils::getFromFloatNorm(cur->arm_mat);
gkQuaternion rot; gkVector3 loc, scl;
gkMathUtils::extractTransformFast(bind, loc, rot, scl);
if (rot.isNaN())
{
rot = gkQuaternion();
scl = gkVector3(1, 1, 1);
}
bone->setRestPosition(gkTransformState(loc, rot, scl));
Blender::Bone* chi = static_cast<Blender::Bone*>(cur->childbase.first);
while (chi)
{
// recurse
buildBoneTree(chi, cur, bone);
chi = chi->next;
}
}
bool gkRaySensor::query(void)
{
#ifdef OGREKIT_USE_PHYSICS
gkVector3 from, to, dir;
bool result;
gkRayTest test;
from = m_object->getWorldPosition();
switch (m_axis)
{
case RA_XPOS: {dir = gkVector3(m_range, 0, 0); break;}
case RA_YPOS: {dir = gkVector3(0, m_range, 0); break;}
case RA_ZPOS: {dir = gkVector3(0, 0, m_range); break;}
case RA_XNEG: {dir = gkVector3(-m_range, 0, 0); break;}
case RA_YNEG: {dir = gkVector3(0, -m_range, 0); break;}
case RA_ZNEG: {dir = gkVector3(0, 0, -m_range); break;}
}
dir = m_object->getWorldOrientation() * dir;
to = from + dir;
if(m_xray){
xrayFilter xrf(m_object, m_prop, m_material);
result = test.collides(from, to, xrf);
}
else
{
gkRayTest::gkRayTestFilter nmf;
result = test.collides(from, to, nmf);
}
bool onlyActorTODO = false;
// if x-ray, m_prop and m_material were already tested
if (!m_xray && result){
gkGameObject* hit = gkPhysicsController::castObject(test.getCollisionObject());
result = hit && gkPhysicsController::sensorTest(hit, m_prop, m_material, onlyActorTODO);
}
return result;
#endif
return false;
}
void gkBlenderMeshConverter::convert_bmesh(void)
{
Blender::MVert* mvert = m_bmesh->mvert;
Blender::MPoly* mpoly = m_bmesh->mpoly;
Blender::MLoop* mloop = m_bmesh->mloop;
Blender::MTexPoly* mtexpoly = m_bmesh->mtpoly;
Blender::MLoopUV* muvloop = m_bmesh->mloopuv;
Blender::MLoopCol* mloopCol = m_bmesh->mloopcol;
// UV-Layer-Data
Blender::MTexPoly* mtpoly[8] = {0, 0, 0, 0, 0, 0, 0, 0};
Blender::MLoopUV* muvs[8] = {0, 0, 0, 0, 0, 0, 0, 0};
bool hasUV = muvloop != 0;
Blender::MVert vpak[4];
unsigned int cpak[4];
unsigned int ipak[4];
int totlayer;
gkSubMesh* curSubMesh = 0;
m_meshtable.clear();
gkLoaderUtils_getLayers_bmesh(m_bmesh, mtpoly,muvs, &mloopCol, totlayer);
bool sortByMat = gkEngine::getSingleton().getUserDefs().blendermat;
bool openglVertexColor = gkEngine::getSingleton().getUserDefs().rendersystem == OGRE_RS_GL;
bool hasTexPoly = mtexpoly != 0;
for (int fi = 0; fi < m_bmesh->totpoly; fi++)
{
const Blender::MPoly& curpoly = mpoly[fi];
const Blender::MTexPoly& curTexPol = mtexpoly[fi];
// skip if face is not a triangle || quad
if (curpoly.totloop<3)
continue;
if (curpoly.totloop>4){
gkLogger::write("Using poly with more than 4 verts is not supported by gkMeshConverter!");
continue;
}
const bool isQuad = curpoly.totloop==4;
TempFace t[2];
PackedFace f;
f.totlay = totlayer;
const Blender::MLoop& v1 = mloop[curpoly.loopstart];
const Blender::MLoop& v2 = mloop[curpoly.loopstart+1];
const Blender::MLoop& v3 = mloop[curpoly.loopstart+2];
if (isQuad)
{
const Blender::MLoop& v4 = mloop[curpoly.loopstart+3];
const Blender::MLoopUV& uv1 = muvloop[curpoly.loopstart];
const Blender::MLoopUV& uv2 = muvloop[curpoly.loopstart+1];
const Blender::MLoopUV& uv3 = muvloop[curpoly.loopstart+2];
const Blender::MLoopUV& uv4 = muvloop[curpoly.loopstart+3];
vpak[0] = mvert[v1.v];
vpak[1] = mvert[v2.v];
vpak[2] = mvert[v3.v];
vpak[3] = mvert[v4.v];
ipak[0] = v1.v;
ipak[1] = v2.v;
ipak[2] = v3.v;
ipak[3] = v4.v;
if (mloopCol != 0)
{
cpak[0] = *(unsigned int*)(mloopCol + curpoly.loopstart);
cpak[1] = *(unsigned int*)(mloopCol + curpoly.loopstart+1);
cpak[2] = *(unsigned int*)(mloopCol + curpoly.loopstart+2);
cpak[3] = *(unsigned int*)(mloopCol + curpoly.loopstart+3);
}
else
cpak[0] = cpak[1] = cpak[2] = cpak[3] = 0xFFFFFFFF;
//TODO: Multitexture!?
for (int i = 0; i < totlayer; i++)
{
if (mtpoly[i] != 0)
{
f.uvLayers[i][0] = gkVector2((float*)&muvs[i][curpoly.loopstart].uv[0]);
f.uvLayers[i][1] = gkVector2((float*)&muvs[i][curpoly.loopstart+1].uv[0]);
f.uvLayers[i][2] = gkVector2((float*)&muvs[i][curpoly.loopstart+2].uv[0]);
f.uvLayers[i][3] = gkVector2((float*)&muvs[i][curpoly.loopstart+3].uv[0]);
}
}
f.verts = vpak;
f.index = ipak;
f.colors = cpak;
// what is this?
gkVector3 e0, e1;
e0 = (gkVector3(mvert[v1.v].co) - gkVector3(mvert[v2.v].co));
e1 = (gkVector3(mvert[v3.v].co) - gkVector3(mvert[v4.v].co));
if (e0.squaredLength() < e1.squaredLength())
{
convertIndexedTriangle(&t[0], 0, 1, 2, f);
convertIndexedTriangle(&t[1], 2, 3, 0, f);
}
else
{
convertIndexedTriangle(&t[0], 0, 1, 3, f);
convertIndexedTriangle(&t[1], 3, 1, 2, f);
}
}
else
{
for (int i = 0; i < totlayer; i++)
{
if (mtpoly[i] != 0)
{
f.uvLayers[i][0] = gkVector2((float*)&muvs[i][curpoly.loopstart].uv[0]);
f.uvLayers[i][1] = gkVector2((float*)&muvs[i][curpoly.loopstart+1].uv[0]);
f.uvLayers[i][2] = gkVector2((float*)&muvs[i][curpoly.loopstart+2].uv[0]);
}
}
vpak[0] = mvert[v1.v];
vpak[1] = mvert[v2.v];
vpak[2] = mvert[v3.v];
ipak[0] = v1.v;
ipak[1] = v2.v;
ipak[2] = v3.v;
if (mloopCol != 0)
{
cpak[0] = *(unsigned int*)(mloopCol + curpoly.loopstart);
cpak[1] = *(unsigned int*)(mloopCol + curpoly.loopstart+1);
cpak[2] = *(unsigned int*)(mloopCol + curpoly.loopstart+2);
}
else
cpak[0] = cpak[1] = cpak[2] = 0xFFFFFFFF;
f.verts = vpak;
f.index = ipak;
f.colors = cpak;
convertIndexedTriangle(&t[0], 0, 1, 2, f);
}
gkMeshPair tester(curSubMesh);
if (sortByMat)
{
int mode = 0;
if (mtpoly[0])
mode = mtpoly[0][fi].mode;
tester.test = gkMeshHashKey(curpoly.mat_nr, mode);
}
else
{
Blender::Image* ima[8] = {0, 0, 0, 0, 0, 0, 0, 0};
for (int i = 0; i < totlayer; i++)
{
if (mtpoly[i] != 0)
ima[i] = mtpoly[i][fi].tpage;
}
int mode = 0, alpha = 0;
if (mtpoly[0])
{
mode = mtpoly[0][fi].mode;
alpha = mtpoly[0][fi].transp;
}
tester.test = gkMeshHashKey(mode, alpha, ima);
}
// find submesh
UTsize arpos = 0;
if ((arpos = m_meshtable.find(tester)) == UT_NPOS)
{
curSubMesh = new gkSubMesh();
curSubMesh->setTotalLayers(totlayer);
curSubMesh->setVertexColors(mloopCol != 0);
m_gmesh->addSubMesh(curSubMesh);
tester.item = curSubMesh;
m_meshtable.push_back(tester);
}
else
curSubMesh = m_meshtable.at(arpos).item;
if (curSubMesh == 0) continue;
if (!(curpoly.flag & ME_SMOOTH))
{
// face normal
calcNormal(&t[0]);
if (isQuad)
t[1].v0.no = t[1].v1.no = t[1].v2.no = t[0].v0.no;
}
// ---- warning -----
// mtpoly[0][fi].mode is always 0 which makes the mesh invisible
// For now setting the standardvalue to collider (which means visible)
// This is afaik the only data I couldn't get in import
int triflag = gkTriangle::TRI_COLLIDER;
if (mtpoly[0])
{
if (mtpoly[0][fi].mode & TF_DYNAMIC)
triflag |= gkTriangle::TRI_COLLIDER;
if (mtpoly[0][fi].mode & TF_INVISIBLE)
triflag |= gkTriangle::TRI_INVISIBLE;
}
else
triflag = gkTriangle::TRI_COLLIDER;
// ---- end warning ------
curSubMesh->addTriangle(t[0].v0, t[0].i0,
t[0].v1, t[0].i1,
t[0].v2, t[0].i2, triflag);
if (isQuad)
{
curSubMesh->addTriangle(t[1].v0, t[1].i0,
t[1].v1, t[1].i1,
t[1].v2, t[1].i2, triflag);
}
}
}
void gkScene::createInstanceImpl(void)
{
if (m_objects.empty())
{
gkPrintf("Scene: '%s' Has no creatable objects.\n", m_name.getName().c_str());
m_instanceState = ST_ERROR;
return;
}
if (!m_window)
setDisplayWindow(gkWindowSystem::getSingleton().getMainWindow());
// generic for now, but later scene properties will be used
// to extract more detailed management information
m_manager = Ogre::Root::getSingleton().createSceneManager(Ogre::ST_GENERIC, m_name.getFullName());
#if OGREKIT_USE_RTSHADER_SYSTEM
Ogre::RTShader::ShaderGenerator::getSingleton().addSceneManager(m_manager);
#endif
m_skybox = gkMaterialLoader::loadSceneSkyMaterial(this, m_baseProps.m_material);
// create the world
(void)getDynamicsWorld();
gkGameObjectHashMap::Iterator it = m_objects.iterator();
while (it.hasMoreElements())
{
gkGameObject* gobj = it.getNext().second;
if (!gobj->isInstanced())
{
// Skip creation of inactive layers
if (m_layers & gobj->getLayer())
{
// call builder
gobj->createInstance();
}
}
}
// Build groups.
gkGroupManager::getSingleton().createGameObjectInstances(this);
if (gkEngine::getSingleton().getUserDefs().buildStaticGeometry)
gkGroupManager::getSingleton().createStaticBatches(this);
// Build parent / child hierarchy.
_applyBuiltinParents(m_instanceObjects);
// Build physics.
_applyBuiltinPhysics(m_instanceObjects);
if (!m_viewport)
{
// setMainCamera has not been called, try to call
if (m_startCam)
setMainCamera(m_startCam);
else
{
if (!m_cameras.empty())
setMainCamera(m_cameras.at(0));
else
{
m_startCam = createCamera(" -- No Camera -- ");
m_startCam->getProperties().m_transform.set(
gkVector3(0, -5, 0),
gkEuler(90.f, 0.f, 0.f).toQuaternion(),
gkVector3(1.f, 1.f, 1.f)
);
m_startCam->createInstance();
setMainCamera(m_startCam);
}
}
}
GK_ASSERT(m_viewport);
m_viewport->getViewport()->setBackgroundColour(m_baseProps.m_material.m_horizon);
m_manager->setAmbientLight(m_baseProps.m_material.m_ambient);
#if OGRE_NO_VIEWPORT_ORIENTATIONMODE != 0
const gkString& iparam = gkEngine::getSingleton().getUserDefs().viewportOrientation;
if (!iparam.empty())
{
int oparam = Ogre::OR_PORTRAIT;
if (iparam == "landscaperight") //viewport orientation is reversed.
{
oparam = Ogre::OR_LANDSCAPELEFT;
// gkLogger::write("Set Orientation: OR_LANDSCAPELEFT",true);
}
else if (iparam == "landscapeleft") {
oparam = Ogre::OR_LANDSCAPERIGHT;
// gkLogger::write("Set Orientation: OR_LANDSCAPERIGHT",true);
}
try{
m_viewport->getViewport()->setOrientationMode((Ogre::OrientationMode)oparam);
} catch (...) {
gkLogger::write("Problem setting Viewport Orientation");
}
}
#endif
if (m_baseProps.m_fog.m_mode != gkFogParams::FM_NONE)
{
m_manager->setFog( m_baseProps.m_fog.m_mode == gkFogParams::FM_QUAD ? Ogre::FOG_EXP2 :
m_baseProps.m_fog.m_mode == gkFogParams::FM_LIN ? Ogre::FOG_LINEAR :
Ogre::FOG_EXP,
m_baseProps.m_fog.m_color,
m_baseProps.m_fog.m_intensity,
m_baseProps.m_fog.m_start,
m_baseProps.m_fog.m_end);
}
//Enable Shadows
setShadows();
#ifdef OGREKIT_OPENAL_SOUND
// Set sound scene.
gkSoundManager& sndMgr = gkSoundManager::getSingleton();
sndMgr.getProperties() = m_soundScene;
sndMgr.updateSoundProperties();
#endif
// notify main scene
gkEngine::getSingleton().registerActiveScene(this);
}
gkProcess* gsProcessManager::createOrientation(gsGameObject* obj, float time, const gsVector3& to)
{
if (obj)
{
gkOrientationProcess* orientationProcess = new gkOrientationProcess(obj->cast<gkGameObject>(),time,gkVector3(to));
return orientationProcess;
}
RETURN_DEFAULTPROCESS(gkString("Problem creating Orientation-Process!"))
}
gkProcess* gsProcessManager::createTranslation(gsGameObject* obj, float time, const gsVector3& from, const gsVector3& to)
{
if (obj)
{
gkTranslationProcess* translationProcess = new gkTranslationProcess(obj->cast<gkGameObject>(),time,gkVector3(from),gkVector3(to));
return translationProcess;
}
RETURN_DEFAULTPROCESS(gkString("Problem creating Translation-Process!"))
}
void gkBlenderSceneConverter::convertObjectConstraints(gkGameObject* gobj, Blender::Object* bobj)
{
// TODO: add more constraints
gkConstraintManager* mgr = m_gscene->getConstraintManager();
for (Blender::bConstraint* bc = (Blender::bConstraint*)bobj->constraints.first; bc; bc = bc->next)
{
if (bc->type == CONSTRAINT_TYPE_RIGIDBODYJOINT)
{
Blender::bRigidBodyJointConstraint* jc = (Blender::bRigidBodyJointConstraint*)bc->data;
gkPhysicsConstraintProperties p;
p.m_target = GKB_IDNAME(jc->tar);
p.m_axis = gkVector3(jc->axX, jc->axY, jc->axZ);
p.m_pivot = gkVector3(jc->pivX, jc->pivY, jc->pivZ);
for (int i = 0; i < 6; i++)
{
p.m_minLimit[i] = jc->minLimit[i];
p.m_maxLimit[i] = jc->maxLimit[i];
}
p.m_flag = jc->flag;
p.m_disableLinkedCollision = (jc->flag & CONSTRAINT_DISABLE_LINKED_COLLISION) != 0;
if (jc->type == CONSTRAINT_RB_BALL)
p.m_type = GK_BALL_CONSTRAINT;
else if (jc->type == CONSTRAINT_RB_HINGE)
p.m_type = GK_HINGE_CONSTRAINT;
else if (jc->type == CONSTRAINT_RB_CONETWIST)
p.m_type = GK_CONETWIST_CONSTRAINT;
else if (jc->type == CONSTRAINT_RB_VEHICLE)
p.m_type = GK_VEHICLE_CONSTRAINT;
else if (jc->type == CONSTRAINT_RB_GENERIC6DOF)
p.m_type = GK_D6_CONSTRAINT;
gobj->getProperties().m_physics.m_constraints.push_back(p);
}
else
{
if (bc->enforce == 0.0)
continue;
gkConstraint* co = 0;
if (bc->type == CONSTRAINT_TYPE_ROTLIMIT)
{
// rotation is in radians.
Blender::bRotLimitConstraint* lr = (Blender::bRotLimitConstraint*)bc->data;
if (!lr->flag)
continue;
gkLimitRotConstraint* c = new gkLimitRotConstraint();
co = c;
if (lr->flag & LIMIT_XROT)
c->setLimitX(gkVector2(lr->xmin * gkDPR, lr->xmax * gkDPR));
if (lr->flag & LIMIT_YROT)
c->setLimitY(gkVector2(lr->ymin * gkDPR, lr->ymax * gkDPR));
if (lr->flag & LIMIT_ZROT)
c->setLimitZ(gkVector2(lr->zmin * gkDPR, lr->zmax * gkDPR));
}
else if (bc->type == CONSTRAINT_TYPE_LOCLIMIT)
{
Blender::bLocLimitConstraint* ll = (Blender::bLocLimitConstraint*)bc->data;
if (!ll->flag)
continue;
gkLimitLocConstraint* c = new gkLimitLocConstraint();
co = c;
if (ll->flag & LIMIT_XMIN) c->setMinX(ll->xmin);
if (ll->flag & LIMIT_XMAX) c->setMaxX(ll->xmax);
if (ll->flag & LIMIT_YMIN) c->setMinY(ll->ymin);
if (ll->flag & LIMIT_YMAX) c->setMaxY(ll->ymax);
if (ll->flag & LIMIT_ZMIN) c->setMinZ(ll->zmin);
if (ll->flag & LIMIT_ZMAX) c->setMaxZ(ll->zmax);
}
if (co)
{
co->setSpace(bc->ownspace == CONSTRAINT_SPACE_LOCAL ? TRANSFORM_LOCAL : TRANSFORM_WORLD);
co->setInfluence(bc->enforce);
mgr->addConstraint(gobj, co);
}
}
}
}
void gkOgreParticleAffector::_affectParticles(Ogre::ParticleSystem* psys, Ogre::Real timeElapsed)
{
GK_ASSERT(m_creator);
gkParticleSettingsProperties& props = m_creator->getParticleProperties();
if (props.m_gravity != 0)
{
Ogre::ParticleIterator pi = psys->_getIterator();
while (!pi.end())
{
Ogre::Particle* p = pi.getNext();
//float size = Ogre::Math::RangeRandom(props.m_size - props.m_sizeRandom, props.m_size + props.m_sizeRandom);
//p->setDimensions(size, size);
gkParticleVisualData* data = static_cast<gkParticleVisualData*>(p->getVisualData());
if (data)
{
p->direction = data->m_initDir + props.m_gravity * (p->totalTimeToLive - p->timeToLive) * gkVector3(0,0,-9.8f);
}
}
}
}
bool
LauncherScene::switchBlockIndex_EM(int i0,int i1) // 交换面板的次序
{
if(i1 < 1 || i1 >= __MAX_BLOCK_NUM||
i0 < 1 || i0 >= __MAX_BLOCK_NUM ||
i0 == i1) // 第0版固定
return false;
if(!m_ppEditBkSwitchAnm[0])
{
m_ppEditBkSwitchAnm[0] = new TranslationAnm(m_pScene,m_ppBlocklist[i0]->getBlockParentPlane(),"blockAnm0",gkVector3(0,0,0));
// m_ppEditBkSwitchAnm[0]->setAnmListener(this);
}
if(!m_ppEditBkSwitchAnm[1])
{
m_ppEditBkSwitchAnm[1] = new TranslationAnm(m_pScene,m_ppBlocklist[i1]->getBlockParentPlane(),"blockAnm1",gkVector3(0,0,0));
// m_ppEditBkSwitchAnm[0]->setAnmListener(this);
}
m_ppEditBkSwitchAnm[0]->finishAnimation();
m_ppEditBkSwitchAnm[1]->finishAnimation();
setBlockOgreAnm_EM(m_ppEditBkSwitchAnm[0],m_ppBlocklist[i0]->getBlockParentPlane(),m_ppBlocklist[i1]->getBlockParentPlane(),m_ppBlocklist[i1]->getRawData());
setBlockOgreAnm_EM(m_ppEditBkSwitchAnm[1],m_ppBlocklist[i1]->getBlockParentPlane(),m_ppBlocklist[i0]->getBlockParentPlane(),m_ppBlocklist[i0]->getRawData());
gkVector3 tempPos = m_ppBlocklist[i0]->getRawData();
m_ppBlocklist[i0]->setRawData(m_ppBlocklist[i1]->getRawData());
m_ppBlocklist[i1]->setRawData(tempPos);
m_ppEditBkSwitchAnm[0]->Fly();
m_ppEditBkSwitchAnm[1]->Fly();
switchBlckBldAnm_EM(i0,i1);
Block* pTemp = m_ppBlocklist[i0];
m_ppBlocklist[i0] = m_ppBlocklist[i1];
m_ppBlocklist[i1] = pTemp;
return true;
}
void gkBlenderMeshConverter::convert_legacy(void)
{
Blender::MFace* mface = m_bmesh->mface;
Blender::MVert* mvert = m_bmesh->mvert;
Blender::MCol* mcol = 0;
Blender::MTFace* mtface[8] = {0, 0, 0, 0, 0, 0, 0, 0};
Blender::MVert vpak[4];
unsigned int cpak[4];
unsigned int ipak[4];
int totlayer;
gkSubMesh* curSubMesh = 0;
m_meshtable.clear();
gkLoaderUtils_getLayers_legacy(m_bmesh, mtface, &mcol, totlayer);
bool sortByMat = gkEngine::getSingleton().getUserDefs().blendermat;
bool openglVertexColor = gkEngine::getSingleton().getUserDefs().rendersystem == OGRE_RS_GL;
for (int fi = 0; fi < m_bmesh->totface; fi++)
{
const Blender::MFace& curface = mface[fi];
// skip if face is not a triangle || quad
if (!curface.v3)
continue;
const bool isQuad = curface.v4 != 0;
TempFace t[2];
PackedFace f;
f.totlay = totlayer;
if (isQuad)
{
vpak[0] = mvert[curface.v1];
vpak[1] = mvert[curface.v2];
vpak[2] = mvert[curface.v3];
vpak[3] = mvert[curface.v4];
ipak[0] = curface.v1;
ipak[1] = curface.v2;
ipak[2] = curface.v3;
ipak[3] = curface.v4;
if (mcol != 0)
{
cpak[0] = packColourABGR(mcol[0]);
cpak[1] = packColourABGR(mcol[1]);
cpak[2] = packColourABGR(mcol[2]);
cpak[3] = packColourABGR(mcol[3]);
}
else
cpak[0] = cpak[1] = cpak[2] = cpak[3] = 0xFFFFFFFF;
for (int i = 0; i < totlayer; i++)
{
if (mtface[i] != 0)
{
f.uvLayers[i][0] = gkVector2((float*)mtface[i][fi].uv[0]);
f.uvLayers[i][1] = gkVector2((float*)mtface[i][fi].uv[1]);
f.uvLayers[i][2] = gkVector2((float*)mtface[i][fi].uv[2]);
f.uvLayers[i][3] = gkVector2((float*)mtface[i][fi].uv[3]);
}
}
f.verts = vpak;
f.index = ipak;
f.colors = cpak;
gkVector3 e0, e1;
e0 = (gkVector3(mvert[curface.v1].co) - gkVector3(mvert[curface.v2].co));
e1 = (gkVector3(mvert[curface.v3].co) - gkVector3(mvert[curface.v4].co));
if (e0.squaredLength() < e1.squaredLength())
{
convertIndexedTriangle(&t[0], 0, 1, 2, f);
convertIndexedTriangle(&t[1], 2, 3, 0, f);
}
else
{
convertIndexedTriangle(&t[0], 0, 1, 3, f);
convertIndexedTriangle(&t[1], 3, 1, 2, f);
}
}
else
{
for (int i = 0; i < totlayer; i++)
{
if (mtface[i] != 0)
{
f.uvLayers[i][0] = gkVector2((float*)mtface[i][fi].uv[0]);
f.uvLayers[i][1] = gkVector2((float*)mtface[i][fi].uv[1]);
f.uvLayers[i][2] = gkVector2((float*)mtface[i][fi].uv[2]);
}
}
vpak[0] = mvert[curface.v1];
vpak[1] = mvert[curface.v2];
vpak[2] = mvert[curface.v3];
ipak[0] = curface.v1;
ipak[1] = curface.v2;
ipak[2] = curface.v3;
if (mcol != 0)
{
cpak[0] = packColourABGR(mcol[0]);
cpak[1] = packColourABGR(mcol[1]);
cpak[2] = packColourABGR(mcol[2]);
}
else
cpak[0] = cpak[1] = cpak[2] = cpak[3] = 0xFFFFFFFF;
f.verts = vpak;
f.index = ipak;
f.colors = cpak;
convertIndexedTriangle(&t[0], 0, 1, 2, f);
}
gkMeshPair tester(curSubMesh);
if (sortByMat)
{
int mode = 0;
if (mtface[0])
mode = mtface[0][fi].mode;
tester.test = gkMeshHashKey(curface.mat_nr, mode);
}
else
{
Blender::Image* ima[8] = {0, 0, 0, 0, 0, 0, 0, 0};
for (int i = 0; i < totlayer; i++)
{
if (mtface[i] != 0)
ima[i] = mtface[i][fi].tpage;
}
int mode = 0, alpha = 0;
if (mtface[0])
{
mode = mtface[0][fi].mode;
alpha = mtface[0][fi].transp;
}
tester.test = gkMeshHashKey(mode, alpha, ima);
}
// find submesh
UTsize arpos = 0;
if ((arpos = m_meshtable.find(tester)) == UT_NPOS)
{
curSubMesh = new gkSubMesh();
curSubMesh->setTotalLayers(totlayer);
curSubMesh->setVertexColors(mcol != 0);
m_gmesh->addSubMesh(curSubMesh);
tester.item = curSubMesh;
m_meshtable.push_back(tester);
}
else
curSubMesh = m_meshtable.at(arpos).item;
if (curSubMesh == 0) continue;
if (!(curface.flag & ME_SMOOTH))
{
// face normal
calcNormal(&t[0]);
if (isQuad)
t[1].v0.no = t[1].v1.no = t[1].v2.no = t[0].v0.no;
}
int triflag = 0;
if (mtface[0])
{
if (mtface[0][fi].mode & TF_DYNAMIC)
triflag |= gkTriangle::TRI_COLLIDER;
if (mtface[0][fi].mode & TF_INVISIBLE)
triflag |= gkTriangle::TRI_INVISIBLE;
}
else
triflag = gkTriangle::TRI_COLLIDER;
curSubMesh->addTriangle(t[0].v0, t[0].i0,
t[0].v1, t[0].i1,
t[0].v2, t[0].i2, triflag);
if (isQuad)
{
curSubMesh->addTriangle(t[1].v0, t[1].i0,
t[1].v1, t[1].i1,
t[1].v2, t[1].i2, triflag);
}
if (mcol)
mcol += 4;
}
}
void gkBlenderMeshConverter::convert(void)
{
Blender::MFace* mface = m_bmesh->mface;
Blender::MVert* mvert = m_bmesh->mvert;
Blender::MCol* mcol = 0;
Blender::MTFace* mtface[8] = {0, 0, 0, 0, 0, 0, 0, 0};
if (!mface || !mvert)
return;
Blender::MVert vpak[4];
unsigned int cpak[4];
unsigned int ipak[4];
int totlayer;
gkSubMesh* curSubMesh = 0;
utArray<gkMeshPair> meshtable;
gkLoaderUtils_getLayers(m_bmesh, mtface, &mcol, totlayer);
bool sortByMat = gkEngine::getSingleton().getUserDefs().blendermat;
bool openglVertexColor = gkEngine::getSingleton().getUserDefs().rendersystem == OGRE_RS_GL;
AssignmentListMap assignMap;
bool canAssign = m_bmesh->dvert && m_bobj->parent && m_bobj->parent->type == OB_ARMATURE;
if (canAssign)
{
int dgi = 0;
for (Blender::bDeformGroup* dg = (Blender::bDeformGroup*)m_bobj->defbase.first; dg; dg = dg->next, ++dgi)
{
m_gmesh->createVertexGroup(dg->name);
convertBoneAssignments(dgi, assignMap);
}
}
for (int fi = 0; fi < m_bmesh->totface; fi++)
{
const Blender::MFace& curface = mface[fi];
// skip if face is not a triangle || quad
if (!curface.v3)
continue;
const bool isQuad = curface.v4 != 0;
TempFace t[2];
PackedFace f;
f.totlay = totlayer;
if (isQuad)
{
vpak[0] = mvert[curface.v1];
vpak[1] = mvert[curface.v2];
vpak[2] = mvert[curface.v3];
vpak[3] = mvert[curface.v4];
ipak[0] = curface.v1;
ipak[1] = curface.v2;
ipak[2] = curface.v3;
ipak[3] = curface.v4;
if (mcol != 0)
{
cpak[0] = packColour(mcol[0], openglVertexColor);
cpak[1] = packColour(mcol[1], openglVertexColor);
cpak[2] = packColour(mcol[2], openglVertexColor);
cpak[3] = packColour(mcol[3], openglVertexColor);
}
else
cpak[0] = cpak[1] = cpak[2] = cpak[3] = 0xFFFFFFFF;
for (int i = 0; i < totlayer; i++)
{
if (mtface[i] != 0)
{
f.uvLayers[i][0] = gkVector2((float*)mtface[i][fi].uv[0]);
f.uvLayers[i][1] = gkVector2((float*)mtface[i][fi].uv[1]);
f.uvLayers[i][2] = gkVector2((float*)mtface[i][fi].uv[2]);
f.uvLayers[i][3] = gkVector2((float*)mtface[i][fi].uv[3]);
}
}
f.verts = vpak;
f.index = ipak;
f.colors = cpak;
gkVector3 e0, e1;
e0 = (gkVector3(mvert[curface.v1].co) - gkVector3(mvert[curface.v2].co));
e1 = (gkVector3(mvert[curface.v3].co) - gkVector3(mvert[curface.v4].co));
if (e0.squaredLength() < e1.squaredLength())
{
convertIndexedTriangle(&t[0], 0, 1, 2, f);
convertIndexedTriangle(&t[1], 2, 3, 0, f);
}
else
{
convertIndexedTriangle(&t[0], 0, 1, 3, f);
convertIndexedTriangle(&t[1], 3, 1, 2, f);
}
}
else
{
for (int i = 0; i < totlayer; i++)
{
if (mtface[i] != 0)
{
f.uvLayers[i][0] = gkVector2((float*)mtface[i][fi].uv[0]);
f.uvLayers[i][1] = gkVector2((float*)mtface[i][fi].uv[1]);
f.uvLayers[i][2] = gkVector2((float*)mtface[i][fi].uv[2]);
}
}
vpak[0] = mvert[curface.v1];
vpak[1] = mvert[curface.v2];
vpak[2] = mvert[curface.v3];
ipak[0] = curface.v1;
ipak[1] = curface.v2;
ipak[2] = curface.v3;
if (mcol != 0)
{
cpak[0] = packColour(mcol[0], openglVertexColor);
cpak[1] = packColour(mcol[1], openglVertexColor);
cpak[2] = packColour(mcol[2], openglVertexColor);
}
else
cpak[0] = cpak[1] = cpak[2] = cpak[3] = 0xFFFFFFFF;
f.verts = vpak;
f.index = ipak;
f.colors = cpak;
convertIndexedTriangle(&t[0], 0, 1, 2, f);
}
gkMeshPair tester(curSubMesh);
if (sortByMat)
{
int mode = 0;
if (mtface[0])
mode = mtface[0][fi].mode;
tester.test = gkMeshHashKey(curface.mat_nr, mode);
}
else
{
Blender::Image* ima[8] = {0, 0, 0, 0, 0, 0, 0, 0};
for (int i = 0; i < totlayer; i++)
{
if (mtface[i] != 0)
ima[i] = mtface[i][fi].tpage;
}
int mode = 0, alpha = 0;
if (mtface[0])
{
mode = mtface[0][fi].mode;
alpha = mtface[0][fi].transp;
}
tester.test = gkMeshHashKey(mode, alpha, ima);
}
// find submesh
UTsize arpos = 0;
if ((arpos = meshtable.find(tester)) == UT_NPOS)
{
curSubMesh = new gkSubMesh();
curSubMesh->setTotalLayers(totlayer);
curSubMesh->setVertexColors(mcol != 0);
m_gmesh->addSubMesh(curSubMesh);
tester.item = curSubMesh;
meshtable.push_back(tester);
}
else
curSubMesh = meshtable.at(arpos).item;
if (curSubMesh == 0) continue;
if (!(curface.flag & ME_SMOOTH))
{
// face normal
calcNormal(&t[0]);
if (isQuad)
t[1].v0.no = t[1].v1.no = t[1].v2.no = t[0].v0.no;
}
int triflag = 0;
if (mtface[0])
{
if (mtface[0][fi].mode & TF_DYNAMIC)
triflag |= gkTriangle::TRI_COLLIDER;
if (mtface[0][fi].mode & TF_INVISIBLE)
triflag |= gkTriangle::TRI_INVISIBLE;
}
else
triflag = gkTriangle::TRI_COLLIDER;
curSubMesh->addTriangle(t[0].v0, t[0].i0,
t[0].v1, t[0].i1,
t[0].v2, t[0].i2, triflag);
if (isQuad)
{
curSubMesh->addTriangle(t[1].v0, t[1].i0,
t[1].v1, t[1].i1,
t[1].v2, t[1].i2, triflag);
}
if (mcol)
mcol += 4;
}
// build materials
utArrayIterator<utArray<gkMeshPair> > iter(meshtable);
while (iter.hasMoreElements())
{
gkMeshHashKey& key = iter.peekNext().test;
gkSubMesh* val = iter.peekNext().item;
Blender::Material* bmat = BlenderMaterial(m_bobj, key.m_matnr);
if (key.m_blenderMat)
{
if (bmat)
convertMaterial(bmat, val->getMaterial(), key);
}
else
convertTextureFace(val->getMaterial(), key, (Blender::Image**)key.m_images);
if (canAssign)
{
// build def groups
assignBoneAssignments(val, assignMap);
}
iter.getNext();
}
}
gsVector3 lerp(const gsVector3& vec1,const gsVector3& vec2, float t)
{
return gsVector3(gkMathUtils::interp(gkVector3(vec1),gkVector3(vec2),t));
}
const gkVector3
ViewNode::getPosition()
{
_ASSERT_(m_pObj);
gkVector3 temp = m_pObj ? m_pObj->getParent()->getPosition()+ m_pObj->getPosition() : gkVector3();
return temp;
}
RatLogic::RatLogic(gkGameObject* obj, SceneLogic* scene, PMOMO momo)
: m_obj(obj),
m_scene(scene),
m_tree(scene->m_tree),
m_momo(momo),
m_characterNode(0),
m_steeringObject(0),
m_steeringCapture(0),
m_steeringFollowing(0),
m_steeringWander(0)
{
m_steeringObject = m_steeringCapture = new gkSteeringCapture(
obj,
velocity::RUN,
FORWARD,
UP,
SIDE,
m_momo->m_obj,
0.5f,
5
);
m_steeringCapture->setMaxForce(10);
m_steeringFollowing = new gkSteeringPathFollowing(
obj,
velocity::RUN,
FORWARD,
UP,
SIDE,
gkVector3(2, 4, 2),
256,
0.003f
);
m_steeringFollowing->setGoalRadius(m_steeringFollowing->radius());
m_steeringFollowing->setGoalPosition(m_momo->m_obj->getPosition());
m_steeringFollowing->setMaxForce(10);
m_steeringWander = new gkSteeringWander(
obj,
velocity::RUN,
FORWARD,
UP,
SIDE,
0.3f,
5
);
m_steeringWander->setMaxForce(10);
m_obj->getChildEntity()->addAnimation(animation::IDLE_STR);
m_obj->getChildEntity()->addAnimation(animation::WALK_STR);
m_obj->getChildEntity()->addAnimation(animation::RUN_STR);
m_obj->getChildEntity()->addAnimation(animation::DEATH_STR);
m_obj->getChildEntity()->addAnimation(animation::STOP_STR);
m_characterNode = m_tree->createNode<gkCharacterNode>();
m_characterNode->setObj(m_obj);
m_characterNode->setForward(m_steeringObject->forward());
{
gkFunctionNode<RatLogic, gkCharacterNode::STATE, FUNCTION_NODE_PARAM_ONE>* updateAINode = m_tree->createNode<gkFunctionNode<RatLogic, gkCharacterNode::STATE, FUNCTION_NODE_PARAM_ONE> >();
updateAINode->getOBJECT()->setValue(this);
updateAINode->getFUNCTION_1()->setValue(&RatLogic::updateAI);
m_characterNode->getINPUT_AI_STATE()->link(updateAINode->getRESULT());
}
gkRayTestNode* hasHit = m_tree->createNode<gkRayTestNode>();
hasHit->getTARGET()->setValue(m_obj);
hasHit->getRAY_DIRECTION()->setValue(gkVector3(0, 0.5f, 0));
// Initial state
m_characterNode->getCURRENT_STATE()->setValue(animation::IDLE);
//IDLE TRANSITION
m_characterNode->addTransition(animation::DEATH, animation::IDLE, 15000);
m_characterNode->addTransition(animation::IDLE, animation::IDLE);
m_characterNode->addTransition(animation::WALK, animation::IDLE);
m_characterNode->addTransition(animation::RUN, animation::IDLE);
m_characterNode->addTransition(animation::STOP, animation::IDLE);
INT_EQUAL_NODE_TYPE* wantToWalk = INT_EQUAL_NODE(m_characterNode->getOUTPUT_AI_STATE(), animation::WALK);
// WALK TRANSITION
IS_TRUE(wantToWalk)->link(m_characterNode->addTransition(animation::IDLE, animation::WALK));
IS_TRUE(wantToWalk)->link(m_characterNode->addTransition(animation::WALK, animation::WALK));
IS_TRUE(wantToWalk)->link(m_characterNode->addTransition(animation::RUN, animation::WALK));
INT_EQUAL_NODE_TYPE* wantToRun = INT_EQUAL_NODE(m_characterNode->getOUTPUT_AI_STATE(), animation::RUN);
// RUN TRANSITION
IS_TRUE(wantToRun)->link(m_characterNode->addTransition(animation::IDLE, animation::RUN));
IS_TRUE(wantToRun)->link(m_characterNode->addTransition(animation::WALK, animation::RUN));
IS_TRUE(wantToRun)->link(m_characterNode->addTransition(animation::RUN, animation::RUN));
//DEATH TRANSITION
{
PGAMEOBJ_EQUAL_NODE_TYPE* ifNode = PGAMEOBJ_EQUAL_NODE(m_momo->m_kickTestNode->getHIT_OBJ(), m_obj);
IS_TRUE(ifNode)->link(m_characterNode->addTransition(animation::IDLE, animation::DEATH));
IS_TRUE(ifNode)->link(m_characterNode->addTransition(animation::RUN, animation::DEATH));
IS_TRUE(ifNode)->link(m_characterNode->addTransition(animation::WALK, animation::DEATH));
m_characterNode->getANIM_NOT_HAS_REACHED_END()->link(m_characterNode->addTransition(animation::DEATH, animation::DEATH));
}
// STOP TRANSITION
{
gkFunctionNode<RatLogic, bool>* stuckNode = m_tree->createNode<gkFunctionNode<RatLogic, bool> >();
stuckNode->getOBJECT()->setValue(this);
stuckNode->getFUNCTION_0()->setValue(&RatLogic::isLogicStuck);
stuckNode->getRESULT()->link(m_characterNode->addTransition(animation::WALK, animation::STOP));
stuckNode->getRESULT()->link(m_characterNode->addTransition(animation::RUN, animation::STOP));
stuckNode->getRESULT()->link(m_characterNode->addTransition(animation::STOP, animation::STOP));
}
gkCharacterNode::MAP map;
typedef gkCharacterNode::StateData StateData;
map[animation::IDLE] = StateData(animation::IDLE, animation::IDLE_STR, true, false, velocity::NONE, true);
map[animation::WALK] = StateData(animation::WALK, animation::WALK_STR, true, false, velocity::WALK, true);
map[animation::RUN] = StateData(animation::RUN, animation::RUN_STR, true, false, velocity::RUN, true);
map[animation::DEATH] = StateData(animation::DEATH, animation::DEATH_STR, false, false, velocity::NONE, true);
map[animation::STOP] = StateData(animation::STOP, animation::STOP_STR, false, false, velocity::NONE, true);
m_characterNode->setMapping(map);
defineLogicStates();
}
void gkGameLevel::spawn()
{
gkGamePlayer* enemy = m_player->clone();
enemy->setPosition(gkVector3(0,1,1));
m_enemies.push_back(enemy);
}
void gkGamePlayer::applyComboThrust(gkScalar fac)
{
gkVector3 m = m_entity->getOrientation() * gkVector3(0, fac, m_physics->getLinearVelocity().z);
m_physics->setLinearVelocity(m);
}
