bool GPG_Application::handleButton(GHOST_IEvent* event, bool isDown) { bool handled = false; MT_assert(event); if (m_mouse) { GHOST_TEventDataPtr eventData = ((GHOST_IEvent*)event)->getData(); GHOST_TEventButtonData* buttonData = static_cast<GHOST_TEventButtonData*>(eventData); GPC_MouseDevice::TButtonId button; switch (buttonData->button) { case GHOST_kButtonMaskMiddle: button = GPC_MouseDevice::buttonMiddle; break; case GHOST_kButtonMaskRight: button = GPC_MouseDevice::buttonRight; break; case GHOST_kButtonMaskLeft: default: button = GPC_MouseDevice::buttonLeft; break; } m_mouse->ConvertButtonEvent(button, isDown); handled = true; } return handled; }
bool KX_RayCast::RayTest(PHY_IPhysicsEnvironment* physics_environment, const MT_Point3& _frompoint, const MT_Point3& topoint, KX_RayCast& callback) { if(physics_environment==NULL) return false; /* prevents crashing in some cases */ // Loops over all physics objects between frompoint and topoint, // calling callback.RayHit for each one. // // callback.RayHit should return true to stop looking, or false to continue. // // returns true if an object was found, false if not. MT_Point3 frompoint(_frompoint); const MT_Vector3 todir( (topoint - frompoint).safe_normalized() ); MT_Point3 prevpoint(_frompoint+todir*(-1.f)); PHY_IPhysicsController* hit_controller; while((hit_controller = physics_environment->rayTest(callback, frompoint.x(),frompoint.y(),frompoint.z(), topoint.x(),topoint.y(),topoint.z())) != NULL) { KX_ClientObjectInfo* info = static_cast<KX_ClientObjectInfo*>(hit_controller->getNewClientInfo()); if (!info) { printf("no info!\n"); MT_assert(info && "Physics controller with no client object info"); break; } // The biggest danger to endless loop, prevent this by checking that the // hit point always progresses along the ray direction.. prevpoint -= callback.m_hitPoint; if (prevpoint.length2() < MT_EPSILON) break; if (callback.RayHit(info)) // caller may decide to stop the loop and still cancel the hit return callback.m_hitFound; // Skip past the object and keep tracing. // Note that retrieving in a single shot multiple hit points would be possible // but it would require some change in Bullet. prevpoint = callback.m_hitPoint; /* We add 0.001 of fudge, so that if the margin && radius == 0., we don't endless loop. */ MT_Scalar marg = 0.001 + hit_controller->GetMargin(); marg *= 2.f; /* Calculate the other side of this object */ MT_Scalar h = MT_abs(todir.dot(callback.m_hitNormal)); if (h <= 0.01) // the normal is almost orthogonal to the ray direction, cannot compute the other side break; marg /= h; frompoint = callback.m_hitPoint + marg * todir; // verify that we are not passed the to point if ((topoint - frompoint).dot(todir) < 0.f) break; } return false; }
bool KX_NormalParentRelation:: UpdateChildCoordinates( SG_Spatial * child, const SG_Spatial * parent, bool& parentUpdated ) { MT_assert(child != NULL); if (!parentUpdated && !child->IsModified()) return false; parentUpdated = true; if (parent==NULL) { /* Simple case */ child->SetWorldFromLocalTransform(); child->ClearModified(); return true; //false; } else { // the childs world locations which we will update. const MT_Vector3 & p_world_scale = parent->GetWorldScaling(); const MT_Point3 & p_world_pos = parent->GetWorldPosition(); const MT_Matrix3x3 & p_world_rotation = parent->GetWorldOrientation(); child->SetWorldScale(p_world_scale * child->GetLocalScale()); child->SetWorldOrientation(p_world_rotation * child->GetLocalOrientation()); child->SetWorldPosition(p_world_pos + p_world_scale * (p_world_rotation * child->GetLocalPosition())); child->ClearModified(); return true; } }
void GlutDrawManager:: InstallDrawer( GlutDrawer * drawer ){ MT_assert(m_drawer == NULL); m_drawer = drawer; }
void GlutMouseManager:: InstallHandler( GlutMouseHandler *handler ){ MT_assert(m_handler == NULL); m_handler = handler; }
void GlutKeyboardManager:: InstallHandler( GlutKeyboardHandler * handler ) { MT_assert(m_handler == NULL); m_handler = handler; }
vector<NG_NetworkMessage*> NG_NetworkScene::FindMessages( const STR_String& to, const STR_String& from, const STR_String& subject, bool spamallowed) { vector<NG_NetworkMessage*> foundmessages; bool notfound = false; // broad phase notfound = ((to.IsEmpty() || spamallowed) ? notfound : m_messagesByDestinationName[to] == NULL); if (!notfound) notfound = (from.IsEmpty() ? notfound : m_messagesBySenderName[from] == NULL); if (!notfound) notfound = (subject.IsEmpty() ? notfound : m_messagesBySubject[subject] == NULL); if (notfound) { // it's definitely NOT in the scene, so stop looking } else { // narrow phase // possibly it's there, but maybe not (false hit) if (to.IsEmpty()) { // take all messages, and check other fields MT_assert(!"objectnames that are empty are not valid, so make it a hobby project :)\n"); } else { //todo: find intersection of messages (that are in other 2 maps) vector<NG_NetworkMessage*>** tolistptr = m_messagesByDestinationName[to]; if (tolistptr) { vector<NG_NetworkMessage*>* tolist = *tolistptr; vector<NG_NetworkMessage*>::iterator listit; for (listit=tolist->begin();!(listit==tolist->end());listit++) { NG_NetworkMessage* message = *listit; if (ConstraintsAreValid(from, subject, message)) { message->AddRef(); foundmessages.push_back(message); } } } // TODO find intersection of messages (that are in other 2 maps) if (spamallowed) { tolistptr = m_messagesByDestinationName[""]; if (tolistptr) { vector<NG_NetworkMessage*>* tolist = *tolistptr; vector<NG_NetworkMessage*>::iterator listit; for (listit=tolist->begin();!(listit==tolist->end());listit++) { NG_NetworkMessage* message = *listit; if (ConstraintsAreValid(from, subject, message)) { message->AddRef(); foundmessages.push_back(message); } } } } } } return foundmessages; }
BL_Uniform::BL_Uniform(int data_size) : mLoc(-1), mDirty(true), mType(UNI_NONE), mTranspose(0), mDataLen(data_size) { #ifdef SORT_UNIFORMS MT_assert((int)mDataLen <= UNIFORM_MAX_LEN); mData = (void*)MEM_mallocN(mDataLen, "shader-uniform-alloc"); #endif }
RAS_ListSlot* RAS_ListRasterizer::FindOrAdd(RAS_MeshSlot& ms) { /* * Keep a copy of constant lists submitted for rendering, * this guards against (replicated)new...delete every frame, * and we can reuse lists! * :: sorted by mesh slot */ RAS_ListSlot* localSlot = (RAS_ListSlot*)ms.m_DisplayList; if (!localSlot) { if (ms.m_pDerivedMesh) { // that means that we draw based on derived mesh, a display list is possible // Note that we come here only for static derived mesh int matnr = ms.m_bucket->GetPolyMaterial()->GetMaterialIndex(); RAS_ListSlot* nullSlot = NULL; RAS_ListSlots *listVector; RAS_DerivedMeshLists::iterator it = mDerivedMeshLists.find(ms.m_pDerivedMesh); if (it == mDerivedMeshLists.end()) { listVector = new RAS_ListSlots(matnr+4, nullSlot); localSlot = new RAS_ListSlot(this); localSlot->m_flag |= LIST_DERIVEDMESH; localSlot->m_matnr = matnr; listVector->at(matnr) = localSlot; mDerivedMeshLists.insert(std::pair<DerivedMesh*, RAS_ListSlots*>(ms.m_pDerivedMesh, listVector)); } else { listVector = it->second; if (listVector->size() <= matnr) listVector->resize(matnr+4, nullSlot); if ((localSlot = listVector->at(matnr)) == NULL) { localSlot = new RAS_ListSlot(this); localSlot->m_flag |= LIST_DERIVEDMESH; localSlot->m_matnr = matnr; listVector->at(matnr) = localSlot; } else { localSlot->AddRef(); } } } else { RAS_ArrayLists::iterator it = mArrayLists.find(ms.m_displayArrays); if (it == mArrayLists.end()) { localSlot = new RAS_ListSlot(this); mArrayLists.insert(std::pair<RAS_DisplayArrayList, RAS_ListSlot*>(ms.m_displayArrays, localSlot)); } else { localSlot = static_cast<RAS_ListSlot*>(it->second->AddRef()); } } } MT_assert(localSlot); return localSlot; }
bool GPG_Application::handleCursorMove(GHOST_IEvent* event) { bool handled = false; MT_assert(event); if (m_mouse && m_mainWindow) { GHOST_TEventDataPtr eventData = ((GHOST_IEvent*)event)->getData(); GHOST_TEventCursorData* cursorData = static_cast<GHOST_TEventCursorData*>(eventData); GHOST_TInt32 x, y; m_mainWindow->screenToClient(cursorData->x, cursorData->y, x, y); m_mouse->ConvertMoveEvent(x, y); handled = true; } return handled; }
int BL_Shader::GetUniformLocation(const char *name) { if ( GLEW_ARB_fragment_shader && GLEW_ARB_vertex_shader && GLEW_ARB_shader_objects ) { MT_assert(mShader!=0); int location = glGetUniformLocationARB(mShader, name); if (location == -1) spit("Invalid uniform value: " << name << "."); return location; } return -1; }
bool GPG_Application::handleKey(GHOST_IEvent* event, bool isDown) { bool handled = false; MT_assert(event); if (m_keyboard) { GHOST_TEventDataPtr eventData = ((GHOST_IEvent*)event)->getData(); GHOST_TEventKeyData* keyData = static_cast<GHOST_TEventKeyData*>(eventData); if (m_keyboard->ToNative(keyData->key) == KX_KetsjiEngine::GetExitKey() && !m_keyboard->m_hookesc && !m_isEmbedded) { m_exitRequested = KX_EXIT_REQUEST_OUTSIDE; } m_keyboard->ConvertEvent(keyData->key, isDown); handled = true; } return handled; }
void BL_Shader::SetUniform(int uniform, const int* val, int len) { if ( GLEW_ARB_fragment_shader && GLEW_ARB_vertex_shader && GLEW_ARB_shader_objects ) { if (len == 2) glUniform2ivARB(uniform, 1, (GLint*)val); else if (len == 3) glUniform3ivARB(uniform, 1, (GLint*)val); else if (len == 4) glUniform4ivARB(uniform, 1, (GLint*)val); else MT_assert(0); } }
bool GPG_Application::handleWheel(GHOST_IEvent* event) { bool handled = false; MT_assert(event); if (m_mouse) { GHOST_TEventDataPtr eventData = ((GHOST_IEvent*)event)->getData(); GHOST_TEventWheelData* wheelData = static_cast<GHOST_TEventWheelData*>(eventData); GPC_MouseDevice::TButtonId button; if (wheelData->z > 0) button = GPC_MouseDevice::buttonWheelUp; else button = GPC_MouseDevice::buttonWheelDown; m_mouse->ConvertButtonEvent(button, true); handled = true; } return handled; }
void KX_BlenderMaterial::setShaderData( bool enable, RAS_IRasterizer *ras) { MT_assert(GLEW_ARB_shader_objects && mShader); int i; if ( !enable || !mShader->Ok() ) { // frame cleanup. if (mShader == mLastShader) { mShader->SetProg(false); mLastShader = NULL; } ras->SetAlphaBlend(TF_SOLID); BL_Texture::DisableAllTextures(); return; } BL_Texture::DisableAllTextures(); mShader->SetProg(true); mLastShader = mShader; BL_Texture::ActivateFirst(); mShader->ApplyShader(); // for each enabled unit for (i=0; i<BL_Texture::GetMaxUnits(); i++) { if (!mTextures[i].Ok()) continue; mTextures[i].ActivateTexture(); mTextures[0].SetMapping(mMaterial->mapping[i].mapping); } if (!mUserDefBlend) { ras->SetAlphaBlend(mMaterial->alphablend); } else { ras->SetAlphaBlend(TF_SOLID); ras->SetAlphaBlend(-1); // indicates custom mode // tested to be valid enums glEnable(GL_BLEND); glBlendFunc(mBlendFunc[0], mBlendFunc[1]); } }
bool GPG_Application::handleKey(GHOST_IEvent* event, bool isDown) { bool handled = false; MT_assert(event); if (m_keyboard) { GHOST_TEventDataPtr eventData = ((GHOST_IEvent*)event)->getData(); GHOST_TEventKeyData* keyData = static_cast<GHOST_TEventKeyData*>(eventData); //no need for this test //if (fSystem->getFullScreen()) { if (keyData->key == GHOST_kKeyEsc && !m_keyboard->m_hookesc && !m_isEmbedded) { m_exitRequested = KX_EXIT_REQUEST_OUTSIDE; } //} m_keyboard->ConvertEvent(keyData->key, isDown); handled = true; } return handled; }
int CParser::Priority(int optorkind) { // returns the priority of an operator // higher number means higher priority switch (optorkind) { case OPor: return 1; case OPand: return 2; case OPgreater: case OPless: case OPgreaterequal: case OPlessequal: case OPequal: case OPunequal: return 3; case OPplus: case OPminus: return 4; case OPmodulus: case OPtimes: case OPdivide: return 5; } MT_assert(false); return 0; // should not happen }
KX_TouchSensor::KX_TouchSensor(SCA_EventManager* eventmgr,KX_GameObject* gameobj,bool bFindMaterial,bool bTouchPulse,const STR_String& touchedpropname) :SCA_ISensor(gameobj,eventmgr), m_touchedpropname(touchedpropname), m_bFindMaterial(bFindMaterial), m_bTouchPulse(bTouchPulse), m_hitMaterial("") /*m_sumoObj(sumoObj),*/ { // KX_TouchEventManager* touchmgr = (KX_TouchEventManager*) eventmgr; // m_resptable = touchmgr->GetResponseTable(); // m_solidHandle = m_sumoObj->getObjectHandle(); m_colliders = new CListValue(); KX_ClientObjectInfo *client_info = gameobj->getClientInfo(); //client_info->m_gameobject = gameobj; //client_info->m_auxilary_info = NULL; client_info->m_sensors.push_back(this); m_physCtrl = gameobj->GetPhysicsController(); MT_assert( !gameobj->GetPhysicsController() || m_physCtrl ); Init(); }
bool KX_VertexParentRelation:: UpdateChildCoordinates( SG_Spatial * child, const SG_Spatial * parent, bool& parentUpdated ) { MT_assert(child != NULL); if (!parentUpdated && !child->IsModified()) return false; child->SetWorldScale(child->GetLocalScale()); if (parent) child->SetWorldPosition(child->GetLocalPosition()+parent->GetWorldPosition()); else child->SetWorldPosition(child->GetLocalPosition()); child->SetWorldOrientation(child->GetLocalOrientation()); child->ClearModified(); return true; //parent != NULL; }
void KX_KetsjiEngine::SetSceneConverter(KX_ISceneConverter* sceneconverter) { MT_assert(sceneconverter); m_sceneconverter = sceneconverter; }
/* * At the moment the GameLogic module is imported into 'pythondictionary' after this function is called. * if this function ever changes to assign a copy, make sure the game logic module is imported into this dictionary before hand. */ void KX_KetsjiEngine::SetPyNamespace(PyObject* pythondictionary) { MT_assert(pythondictionary); m_pythondictionary = pythondictionary; }
void KX_KetsjiEngine::SetRasterizer(RAS_IRasterizer* rasterizer) { MT_assert(rasterizer); m_rasterizer = rasterizer; }
void KX_KetsjiEngine::SetRenderTools(RAS_IRenderTools* rendertools) { MT_assert(rendertools); m_rendertools = rendertools; }
void KX_KetsjiEngine::SetCanvas(RAS_ICanvas* canvas) { MT_assert(canvas); m_canvas = canvas; }
void KX_KetsjiEngine::SetNetworkDevice(NG_NetworkDeviceInterface* networkdevice) { MT_assert(networkdevice); m_networkdevice = networkdevice; }
void KX_KetsjiEngine::SetMouseDevice(SCA_IInputDevice* mousedevice) { MT_assert(mousedevice); m_mousedevice = mousedevice; }
void KX_KetsjiEngine::SetKeyboardDevice(SCA_IInputDevice* keyboarddevice) { MT_assert(keyboarddevice); m_keyboarddevice = keyboarddevice; }
bool KX_SlowParentRelation:: UpdateChildCoordinates( SG_Spatial * child, const SG_Spatial * parent, bool& parentUpdated ) { MT_assert(child != NULL); // the child will move even if the parent is not parentUpdated = true; const MT_Vector3 & child_scale = child->GetLocalScale(); const MT_Point3 & child_pos = child->GetLocalPosition(); const MT_Matrix3x3 & child_rotation = child->GetLocalOrientation(); // the childs world locations which we will update. MT_Vector3 child_w_scale; MT_Point3 child_w_pos; MT_Matrix3x3 child_w_rotation; if (parent) { // This is a slow parent relation // first compute the normal child world coordinates. MT_Vector3 child_n_scale; MT_Point3 child_n_pos; MT_Matrix3x3 child_n_rotation; const MT_Vector3 & p_world_scale = parent->GetWorldScaling(); const MT_Point3 & p_world_pos = parent->GetWorldPosition(); const MT_Matrix3x3 & p_world_rotation = parent->GetWorldOrientation(); child_n_scale = p_world_scale * child_scale; child_n_rotation = p_world_rotation * child_rotation; child_n_pos = p_world_pos + p_world_scale * (p_world_rotation * child_pos); if (m_initialized) { // get the current world positions child_w_scale = child->GetWorldScaling(); child_w_pos = child->GetWorldPosition(); child_w_rotation = child->GetWorldOrientation(); // now 'interpolate' the normal coordinates with the last // world coordinates to get the new world coordinates. MT_Scalar weight = MT_Scalar(1)/(m_relax + 1); child_w_scale = (m_relax * child_w_scale + child_n_scale) * weight; child_w_pos = (m_relax * child_w_pos + child_n_pos) * weight; // for rotation we must go through quaternion MT_Quaternion child_w_quat = child_w_rotation.getRotation().slerp(child_n_rotation.getRotation(), weight); child_w_rotation.setRotation(child_w_quat); //FIXME: update physics controller. } else { child_w_scale = child_n_scale; child_w_pos = child_n_pos; child_w_rotation = child_n_rotation; m_initialized = true; } } else { child_w_scale = child_scale; child_w_pos = child_pos; child_w_rotation = child_rotation; } child->SetWorldScale(child_w_scale); child->SetWorldPosition(child_w_pos); child->SetWorldOrientation(child_w_rotation); child->ClearModified(); // this node must always be updated, so reschedule it for next time child->ActivateRecheduleUpdateCallback(); return true; //parent != NULL; }
bool KX_BoneParentRelation:: UpdateChildCoordinates( SG_Spatial * child, const SG_Spatial * parent, bool& parentUpdated ) { MT_assert(child != NULL); // This way of accessing child coordinates is a bit cumbersome // be nice to have non constant reference access to these values. const MT_Vector3 & child_scale = child->GetLocalScale(); const MT_Point3 & child_pos = child->GetLocalPosition(); const MT_Matrix3x3 & child_rotation = child->GetLocalOrientation(); // we don't know if the armature has been updated or not, assume yes parentUpdated = true; // the childs world locations which we will update. MT_Vector3 child_w_scale; MT_Point3 child_w_pos; MT_Matrix3x3 child_w_rotation; bool valid_parent_transform = false; if (parent) { BL_ArmatureObject *armature = (BL_ArmatureObject*)(parent->GetSGClientObject()); if (armature) { MT_Matrix4x4 parent_matrix; if (armature->GetBoneMatrix(m_bone, parent_matrix)) { // Get the child's transform, and the bone matrix. MT_Matrix4x4 child_transform ( MT_Transform(child_pos + MT_Vector3(0.0f, armature->GetBoneLength(m_bone), 0.0f), child_rotation.scaled( child_scale[0], child_scale[1], child_scale[2]))); // The child's world transform is parent * child parent_matrix = parent->GetWorldTransform() * parent_matrix; child_transform = parent_matrix * child_transform; // Recompute the child transform components from the transform. child_w_scale.setValue( MT_Vector3(child_transform[0][0], child_transform[0][1], child_transform[0][2]).length(), MT_Vector3(child_transform[1][0], child_transform[1][1], child_transform[1][2]).length(), MT_Vector3(child_transform[2][0], child_transform[2][1], child_transform[2][2]).length()); child_w_rotation.setValue(child_transform[0][0], child_transform[0][1], child_transform[0][2], child_transform[1][0], child_transform[1][1], child_transform[1][2], child_transform[2][0], child_transform[2][1], child_transform[2][2]); child_w_rotation.scale(1.0f/child_w_scale[0], 1.0f/child_w_scale[1], 1.0f/child_w_scale[2]); child_w_pos = MT_Point3(child_transform[0][3], child_transform[1][3], child_transform[2][3]); valid_parent_transform = true; } } } if (valid_parent_transform) { child->SetWorldScale(child_w_scale); child->SetWorldPosition(child_w_pos); child->SetWorldOrientation(child_w_rotation); } else { child->SetWorldFromLocalTransform(); } child->ClearModified(); // this node must always be updated, so reschedule it for next time child->ActivateRecheduleUpdateCallback(); return valid_parent_transform; }
void BL_Uniform::Apply(class BL_Shader *shader) { #ifdef SORT_UNIFORMS MT_assert(mType > UNI_NONE && mType < UNI_MAX && mData); if (!mDirty) return; switch (mType) { case UNI_FLOAT: { float *f = (float*)mData; glUniform1fARB(mLoc,(GLfloat)*f); break; } case UNI_INT: { int *f = (int*)mData; glUniform1iARB(mLoc, (GLint)*f); break; } case UNI_FLOAT2: { float *f = (float*)mData; glUniform2fvARB(mLoc,1, (GLfloat*)f); break; } case UNI_FLOAT3: { float *f = (float*)mData; glUniform3fvARB(mLoc,1,(GLfloat*)f); break; } case UNI_FLOAT4: { float *f = (float*)mData; glUniform4fvARB(mLoc,1,(GLfloat*)f); break; } case UNI_INT2: { int *f = (int*)mData; glUniform2ivARB(mLoc,1,(GLint*)f); break; } case UNI_INT3: { int *f = (int*)mData; glUniform3ivARB(mLoc,1,(GLint*)f); break; } case UNI_INT4: { int *f = (int*)mData; glUniform4ivARB(mLoc,1,(GLint*)f); break; } case UNI_MAT4: { float *f = (float*)mData; glUniformMatrix4fvARB(mLoc, 1, mTranspose?GL_TRUE:GL_FALSE,(GLfloat*)f); break; } case UNI_MAT3: { float *f = (float*)mData; glUniformMatrix3fvARB(mLoc, 1, mTranspose?GL_TRUE:GL_FALSE,(GLfloat*)f); break; } } mDirty = false; #endif }