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); }