/** * $Id$ * * ***** BEGIN GPL LICENSE BLOCK ***** * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software Foundation, * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. * All rights reserved. * * The Original Code is: all of this file. * * Contributor(s): none yet. * * ***** END GPL LICENSE BLOCK ***** * KX_MouseFocusSensor determines mouse in/out/over events. */ #ifdef WIN32 // This warning tells us about truncation of __long__ stl-generated names. // It can occasionally cause DevStudio to have internal compiler warnings. #pragma warning( disable : 4786 ) #endif #include "MT_Point3.h" #include "RAS_FramingManager.h" #include "RAS_ICanvas.h" #include "RAS_IRasterizer.h" #include "SCA_IScene.h" #include "KX_Scene.h" #include "KX_Camera.h" #include "KX_MouseFocusSensor.h" #include "KX_PyMath.h" #include "KX_RayCast.h" #include "KX_IPhysicsController.h" #include "PHY_IPhysicsController.h" #include "PHY_IPhysicsEnvironment.h" #include "KX_ClientObjectInfo.h" /* ------------------------------------------------------------------------- */ /* Native functions */ /* ------------------------------------------------------------------------- */ KX_MouseFocusSensor::KX_MouseFocusSensor(SCA_MouseManager* eventmgr, int startx, int starty, short int mousemode, int focusmode, KX_Scene* kxscene, KX_KetsjiEngine *kxengine, SCA_IObject* gameobj, PyTypeObject* T) : SCA_MouseSensor(eventmgr, startx, starty, mousemode, gameobj, T), m_focusmode(focusmode), m_kxscene(kxscene), m_kxengine(kxengine) { Init(); } void KX_MouseFocusSensor::Init() { m_mouse_over_in_previous_frame = (m_invert)?true:false; m_positive_event = false; m_hitObject = 0; m_reset = true; m_hitPosition.setValue(0,0,0); m_prevTargetPoint.setValue(0,0,0); m_prevSourcePoint.setValue(0,0,0); m_hitNormal.setValue(0,0,1); } bool KX_MouseFocusSensor::Evaluate(CValue* event) { bool result = false; bool obHasFocus = false; bool reset = m_reset && m_level; // cout << "evaluate focus mouse sensor "<m_gameobject; /* Is this me? In the ray test, there are a lot of extra checks * for aliasing artefacts from self-hits. That doesn't happen * here, so a simple test suffices. Or does the camera also get * self-hits? (No, and the raysensor shouldn't do it either, since * self-hits are excluded by setting the correct ignore-object.) * Hitspots now become valid. */ KX_GameObject* thisObj = (KX_GameObject*) GetParent(); if ((m_focusmode == 2) || hitKXObj == thisObj) { m_hitObject = hitKXObj; m_hitPosition = result->m_hitPoint; m_hitNormal = result->m_hitNormal; return true; } return true; // object must be visible to trigger //return false; // occluded objects can trigger } bool KX_MouseFocusSensor::ParentObjectHasFocusCamera(KX_Camera *cam) { /* All screen handling in the gameengine is done by GL, * specifically the model/view and projection parts. The viewport * part is in the creator. * * The theory is this: * WCS - world coordinates * -> wcs_camcs_trafo -> * camCS - camera coordinates * -> camcs_clip_trafo -> * clipCS - normalized device coordinates? * -> normview_win_trafo * winCS - window coordinates * * The first two transforms are respectively the model/view and * the projection matrix. These are passed to the rasterizer, and * we store them in the camera for easy access. * * For normalized device coords (xn = x/w, yn = y/w/zw) the * windows coords become (lb = left bottom) * * xwin = [(xn + 1.0) * width]/2 + x_lb * ywin = [(yn + 1.0) * height]/2 + y_lb * * Inverting (blender y is flipped!): * * xn = 2(xwin - x_lb)/width - 1.0 * yn = 2(ywin - y_lb)/height - 1.0 * = 2(height - y_blender - y_lb)/height - 1.0 * = 1.0 - 2(y_blender - y_lb)/height * * */ /* Because we don't want to worry about resize events, camera * changes and all that crap, we just determine this over and * over. Stop whining. We have lots of other calculations to do * here as well. These reads are not the main cost. If there is no * canvas, the test is irrelevant. The 1.0 makes sure the * calculations don't bomb. Maybe we should explicitly guard for * division by 0.0...*/ RAS_Rect area, viewport; m_kxengine->GetSceneViewport(m_kxscene, cam, area, viewport); /* Check if the mouse is in the viewport */ if (( m_x < viewport.m_x2 && // less then right m_x > viewport.m_x1 && // more then then left m_y < viewport.m_y2 && // below top m_y > viewport.m_y1) == 0) // above bottom { return false; } float height = float(viewport.m_y2 - viewport.m_y1 + 1); float width = float(viewport.m_x2 - viewport.m_x1 + 1); float x_lb = float(viewport.m_x1); float y_lb = float(viewport.m_y1); MT_Vector4 frompoint; MT_Vector4 topoint; /* There's some strangeness I don't fully get here... These values * _should_ be wrong! - see from point Z values */ /* build the from and to point in normalized device coordinates * Looks like normailized device coordinates are [-1,1] in x [-1,1] in y * [0,-1] in z * * The actual z coordinates used don't have to be exact just infront and * behind of the near and far clip planes. */ frompoint.setValue( (2 * (m_x-x_lb) / width) - 1.0, 1.0 - (2 * (m_y - y_lb) / height), 0.0, /* nearclip, see above comments */ 1.0 ); topoint.setValue( (2 * (m_x-x_lb) / width) - 1.0, 1.0 - (2 * (m_y-y_lb) / height), 1.0, /* farclip, see above comments */ 1.0 ); /* camera to world */ MT_Transform wcs_camcs_tranform = cam->GetWorldToCamera(); if (!cam->GetCameraData()->m_perspective) wcs_camcs_tranform.getOrigin()[2] *= 100.0; MT_Transform cams_wcs_transform; cams_wcs_transform.invert(wcs_camcs_tranform); MT_Matrix4x4 camcs_wcs_matrix = MT_Matrix4x4(cams_wcs_transform); /* badly defined, the first time round.... I wonder why... I might * want to guard against floating point errors here.*/ MT_Matrix4x4 clip_camcs_matrix = MT_Matrix4x4(cam->GetProjectionMatrix()); clip_camcs_matrix.invert(); /* shoot-points: clip to cam to wcs . win to clip was already done.*/ frompoint = clip_camcs_matrix * frompoint; topoint = clip_camcs_matrix * topoint; frompoint = camcs_wcs_matrix * frompoint; topoint = camcs_wcs_matrix * topoint; /* from hom wcs to 3d wcs: */ m_prevSourcePoint.setValue( frompoint[0]/frompoint[3], frompoint[1]/frompoint[3], frompoint[2]/frompoint[3]); m_prevTargetPoint.setValue( topoint[0]/topoint[3], topoint[1]/topoint[3], topoint[2]/topoint[3]); /* 2. Get the object from PhysicsEnvironment */ /* Shoot! Beware that the first argument here is an * ignore-object. We don't ignore anything... */ KX_IPhysicsController* physics_controller = cam->GetPhysicsController(); PHY_IPhysicsEnvironment* physics_environment = m_kxscene->GetPhysicsEnvironment(); KX_RayCast::Callback callback(this,physics_controller); KX_RayCast::RayTest(physics_environment, m_prevSourcePoint, m_prevTargetPoint, callback); if (m_hitObject) return true; return false; } bool KX_MouseFocusSensor::ParentObjectHasFocus() { m_hitObject = 0; m_hitPosition.setValue(0,0,0); m_hitNormal.setValue(1,0,0); KX_Camera *cam= m_kxscene->GetActiveCamera(); if(ParentObjectHasFocusCamera(cam)) return true; list* cameras = m_kxscene->GetCameras(); list::iterator it = cameras->begin(); while(it != cameras->end()) { if(((*it) != cam) && (*it)->GetViewport()) if (ParentObjectHasFocusCamera(*it)) return true; it++; } return false; } const MT_Point3& KX_MouseFocusSensor::RaySource() const { return m_prevSourcePoint; } const MT_Point3& KX_MouseFocusSensor::RayTarget() const { return m_prevTargetPoint; } const MT_Point3& KX_MouseFocusSensor::HitPosition() const { return m_hitPosition; } const MT_Vector3& KX_MouseFocusSensor::HitNormal() const { return m_hitNormal; } /* ------------------------------------------------------------------------- */ /* Python functions */ /* ------------------------------------------------------------------------- */ /* Integration hooks ------------------------------------------------------- */ PyTypeObject KX_MouseFocusSensor::Type = { PyObject_HEAD_INIT(NULL) 0, "KX_MouseFocusSensor", sizeof(PyObjectPlus_Proxy), 0, py_base_dealloc, 0, 0, 0, 0, py_base_repr, 0,0,0,0,0,0, py_base_getattro, py_base_setattro, 0,0,0,0,0,0,0,0,0, Methods }; PyParentObject KX_MouseFocusSensor::Parents[] = { &KX_MouseFocusSensor::Type, &SCA_MouseSensor::Type, &SCA_ISensor::Type, &SCA_ILogicBrick::Type, &CValue::Type, NULL }; PyMethodDef KX_MouseFocusSensor::Methods[] = { {"getRayTarget", (PyCFunction) KX_MouseFocusSensor::sPyGetRayTarget, METH_NOARGS, (PY_METHODCHAR)GetRayTarget_doc}, {"getRaySource", (PyCFunction) KX_MouseFocusSensor::sPyGetRaySource, METH_NOARGS, (PY_METHODCHAR)GetRaySource_doc}, {"getHitObject",(PyCFunction) KX_MouseFocusSensor::sPyGetHitObject,METH_NOARGS, (PY_METHODCHAR)GetHitObject_doc}, {"getHitPosition",(PyCFunction) KX_MouseFocusSensor::sPyGetHitPosition,METH_NOARGS, (PY_METHODCHAR)GetHitPosition_doc}, {"getHitNormal",(PyCFunction) KX_MouseFocusSensor::sPyGetHitNormal,METH_NOARGS, (PY_METHODCHAR)GetHitNormal_doc}, {"getRayDirection",(PyCFunction) KX_MouseFocusSensor::sPyGetRayDirection,METH_NOARGS, (PY_METHODCHAR)GetRayDirection_doc}, {NULL,NULL} //Sentinel }; PyAttributeDef KX_MouseFocusSensor::Attributes[] = { KX_PYATTRIBUTE_RO_FUNCTION("raySource", KX_MouseFocusSensor, pyattr_get_ray_source), KX_PYATTRIBUTE_RO_FUNCTION("rayTarget", KX_MouseFocusSensor, pyattr_get_ray_target), KX_PYATTRIBUTE_RO_FUNCTION("rayDirection", KX_MouseFocusSensor, pyattr_get_ray_direction), KX_PYATTRIBUTE_RO_FUNCTION("hitObject", KX_MouseFocusSensor, pyattr_get_hit_object), KX_PYATTRIBUTE_RO_FUNCTION("hitPosition", KX_MouseFocusSensor, pyattr_get_hit_position), KX_PYATTRIBUTE_RO_FUNCTION("hitNormal", KX_MouseFocusSensor, pyattr_get_hit_normal), { NULL } //Sentinel }; PyObject* KX_MouseFocusSensor::py_getattro(PyObject *attr) { py_getattro_up(SCA_MouseSensor); } const char KX_MouseFocusSensor::GetHitObject_doc[] = "getHitObject()\n" "\tReturns the object that was hit by this ray.\n"; PyObject* KX_MouseFocusSensor::PyGetHitObject() { ShowDeprecationWarning("GetHitObject()", "the hitObject property"); if (m_hitObject) return m_hitObject->GetProxy(); Py_RETURN_NONE; } const char KX_MouseFocusSensor::GetHitPosition_doc[] = "getHitPosition()\n" "\tReturns the position (in worldcoordinates) where the object was hit by this ray.\n"; PyObject* KX_MouseFocusSensor::PyGetHitPosition() { ShowDeprecationWarning("getHitPosition()", "the hitPosition property"); return PyObjectFrom(m_hitPosition); } const char KX_MouseFocusSensor::GetRayDirection_doc[] = "getRayDirection()\n" "\tReturns the direction from the ray (in worldcoordinates) .\n"; PyObject* KX_MouseFocusSensor::PyGetRayDirection() { ShowDeprecationWarning("getRayDirection()", "the rayDirection property"); MT_Vector3 dir = m_prevTargetPoint - m_prevSourcePoint; if(MT_fuzzyZero(dir)) dir.setValue(0,0,0); else dir.normalize(); return PyObjectFrom(dir); } const char KX_MouseFocusSensor::GetHitNormal_doc[] = "getHitNormal()\n" "\tReturns the normal (in worldcoordinates) at the point of collision where the object was hit by this ray.\n"; PyObject* KX_MouseFocusSensor::PyGetHitNormal() { ShowDeprecationWarning("getHitNormal()", "the hitNormal property"); return PyObjectFrom(m_hitNormal); } /* getRayTarget */ const char KX_MouseFocusSensor::GetRayTarget_doc[] = "getRayTarget()\n" "\tReturns the target of the ray that seeks the focus object,\n" "\tin worldcoordinates."; PyObject* KX_MouseFocusSensor::PyGetRayTarget() { ShowDeprecationWarning("getRayTarget()", "the rayTarget property"); return PyObjectFrom(m_prevTargetPoint); } /* getRayTarget */ const char KX_MouseFocusSensor::GetRaySource_doc[] = "getRaySource()\n" "\tReturns the source of the ray that seeks the focus object,\n" "\tin worldcoordinates."; PyObject* KX_MouseFocusSensor::PyGetRaySource() { ShowDeprecationWarning("getRaySource()", "the raySource property"); return PyObjectFrom(m_prevSourcePoint); } /* Attributes */ PyObject* KX_MouseFocusSensor::pyattr_get_ray_source(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef) { KX_MouseFocusSensor* self= static_cast(self_v); return PyObjectFrom(self->RaySource()); } PyObject* KX_MouseFocusSensor::pyattr_get_ray_target(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef) { KX_MouseFocusSensor* self= static_cast(self_v); return PyObjectFrom(self->RayTarget()); } PyObject* KX_MouseFocusSensor::pyattr_get_ray_direction(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef) { KX_MouseFocusSensor* self= static_cast(self_v); MT_Vector3 dir = self->RayTarget() - self->RaySource(); if(MT_fuzzyZero(dir)) dir.setValue(0,0,0); else dir.normalize(); return PyObjectFrom(dir); } PyObject* KX_MouseFocusSensor::pyattr_get_hit_object(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef) { KX_MouseFocusSensor* self= static_cast(self_v); if(self->m_hitObject) return self->m_hitObject->GetProxy(); Py_RETURN_NONE; } PyObject* KX_MouseFocusSensor::pyattr_get_hit_position(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef) { KX_MouseFocusSensor* self= static_cast(self_v); return PyObjectFrom(self->HitPosition()); } PyObject* KX_MouseFocusSensor::pyattr_get_hit_normal(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef) { KX_MouseFocusSensor* self= static_cast(self_v); return PyObjectFrom(self->HitNormal()); } /* eof */