added Camera.computePickRay()

examples/cameraExample.js

@@ -76,6 +76,16 @@ function checkCamera() {
 
 Script.willSendVisualDataCallback.connect(checkCamera);
 
+function mouseMoveEvent(event) {
+    print("mouseMoveEvent event.x,y=" + event.x + ", " + event.y);
+    var pickRay = Camera.computePickRay(event.x, event.y);
+    print("called Camera.computePickRay()");
+    print("computePickRay origin=" + pickRay.origin.x + ", " + pickRay.origin.y + ", " + pickRay.origin.z);
+    print("computePickRay direction=" + pickRay.direction.x + ", " + pickRay.direction.y + ", " + pickRay.direction.z);
+}
+
+Controller.mouseMoveEvent.connect(mouseMoveEvent);
+
 
 function keyPressEvent(event) {
     if (joysticksCaptured) {

interface/src/Application.cpp

@@ -4097,7 +4097,7 @@ void Application::loadScript(const QString& fileNameString) {
     // hook our avatar object into this script engine
     scriptEngine->setAvatarData( static_cast<Avatar*>(_myAvatar), "MyAvatar");
 
-    CameraScriptableObject* cameraScriptable = new CameraScriptableObject(&_myCamera);
+    CameraScriptableObject* cameraScriptable = new CameraScriptableObject(&_myCamera, &_viewFrustum);
     scriptEngine->registerGlobalObject("Camera", cameraScriptable);
     connect(scriptEngine, SIGNAL(finished(const QString&)), cameraScriptable, SLOT(deleteLater()));
 

interface/src/Camera.cpp

@@ -8,7 +8,9 @@
 
 #include <SharedUtil.h>
 #include <VoxelConstants.h>
+#include <EventTypes.h>
 
+#include "Application.h"
 #include "Camera.h"
 #include "Menu.h"
 #include "Util.h"
@@ -168,22 +170,22 @@ void Camera::setAspectRatio(float a) {
     _frustumNeedsReshape = true; 
 }
 
-void Camera::setNearClip   (float n) { 
+void Camera::setNearClip(float n) { 
     _nearClip = n; 
     _frustumNeedsReshape = true; 
 }
 
-void Camera::setFarClip    (float f) { 
+void Camera::setFarClip(float f) { 
     _farClip = f; 
     _frustumNeedsReshape = true; 
 }
 
-void Camera::setEyeOffsetPosition  (const glm::vec3& p) {
+void Camera::setEyeOffsetPosition(const glm::vec3& p) {
     _eyeOffsetPosition = p;
     _frustumNeedsReshape = true;
 }
 
-void Camera::setEyeOffsetOrientation  (const glm::quat& o) {
+void Camera::setEyeOffsetOrientation(const glm::quat& o) {
     _eyeOffsetOrientation = o;
     _frustumNeedsReshape = true;
 }
@@ -221,6 +223,19 @@ void Camera::setFrustumWasReshaped() {
 }
 
 
+CameraScriptableObject::CameraScriptableObject(Camera* camera, ViewFrustum* viewFrustum) :
+    _camera(camera), _viewFrustum(viewFrustum) 
+{
+}
+
+PickRay CameraScriptableObject::computePickRay(float x, float y) {
+    float screenWidth = Application::getInstance()->getGLWidget()->width();
+    float screenHeight = Application::getInstance()->getGLWidget()->height();
+    PickRay result;
+    _viewFrustum->computePickRay(x / screenWidth, y / screenHeight, result.origin, result.direction);
+    return result;
+}
+
 QString CameraScriptableObject::getMode() const {
     QString mode("unknown");
     switch(_camera->getMode()) {

interface/src/Camera.h

@@ -10,6 +10,8 @@
 
 #include <glm/glm.hpp>
 #include <glm/gtc/quaternion.hpp>
+#include <RegisteredMetaTypes.h>
+#include <ViewFrustum.h>
 
 const float DEFAULT_FIELD_OF_VIEW_DEGREES = 90.0f;
 
@@ -105,7 +107,7 @@ private:
 class CameraScriptableObject  : public QObject {
     Q_OBJECT
 public:
-    CameraScriptableObject(Camera* camera) { _camera = camera; }
+    CameraScriptableObject(Camera* camera, ViewFrustum* viewFrustum);
 
 public slots:
     QString getMode() const;
@@ -117,7 +119,10 @@ public slots:
     void setOrientation(const glm::quat& value) { _camera->setTargetRotation(value); }
     glm::quat getOrientation() const { return _camera->getRotation(); }
 
+    PickRay computePickRay(float x, float y);
+
 private:
     Camera* _camera;
+    ViewFrustum* _viewFrustum;
 };
 #endif

libraries/script-engine/src/EventTypes.cpp

@@ -124,7 +124,7 @@ QScriptValue keyEventToScriptValue(QScriptEngine* engine, const KeyEvent& event)
     return obj;
 }
 
-void keyEventFromScriptValue(const QScriptValue &object, KeyEvent& event) {
+void keyEventFromScriptValue(const QScriptValue& object, KeyEvent& event) {
 
     event.isValid = false; // assume the worst
     event.isMeta = object.property("isMeta").toVariant().toBool();
@@ -231,7 +231,7 @@ QScriptValue mouseEventToScriptValue(QScriptEngine* engine, const MouseEvent& ev
     return obj;
 }
 
-void mouseEventFromScriptValue(const QScriptValue &object, MouseEvent& event) {
+void mouseEventFromScriptValue(const QScriptValue& object, MouseEvent& event) {
     // nothing for now...
 }
 
@@ -242,7 +242,7 @@ QScriptValue touchEventToScriptValue(QScriptEngine* engine, const TouchEvent& ev
     return obj;
 }
 
-void touchEventFromScriptValue(const QScriptValue &object, TouchEvent& event) {
+void touchEventFromScriptValue(const QScriptValue& object, TouchEvent& event) {
     // nothing for now...
 }
 
@@ -253,6 +253,8 @@ QScriptValue wheelEventToScriptValue(QScriptEngine* engine, const WheelEvent& ev
     return obj;
 }
 
-void wheelEventFromScriptValue(const QScriptValue &object, WheelEvent& event) {
+void wheelEventFromScriptValue(const QScriptValue& object, WheelEvent& event) {
     // nothing for now...
 }
+
+

libraries/script-engine/src/EventTypes.h

@@ -65,7 +65,6 @@ public:
     int y;
 };
 
-
 Q_DECLARE_METATYPE(KeyEvent)
 Q_DECLARE_METATYPE(MouseEvent)
 Q_DECLARE_METATYPE(TouchEvent)
@@ -74,15 +73,15 @@ Q_DECLARE_METATYPE(WheelEvent)
 void registerEventTypes(QScriptEngine* engine);
 
 QScriptValue keyEventToScriptValue(QScriptEngine* engine, const KeyEvent& event);
-void keyEventFromScriptValue(const QScriptValue &object, KeyEvent& event);
+void keyEventFromScriptValue(const QScriptValue& object, KeyEvent& event);
 
 QScriptValue mouseEventToScriptValue(QScriptEngine* engine, const MouseEvent& event);
-void mouseEventFromScriptValue(const QScriptValue &object, MouseEvent& event);
+void mouseEventFromScriptValue(const QScriptValue& object, MouseEvent& event);
 
 QScriptValue touchEventToScriptValue(QScriptEngine* engine, const TouchEvent& event);
-void touchEventFromScriptValue(const QScriptValue &object, TouchEvent& event);
+void touchEventFromScriptValue(const QScriptValue& object, TouchEvent& event);
 
 QScriptValue wheelEventToScriptValue(QScriptEngine* engine, const WheelEvent& event);
-void wheelEventFromScriptValue(const QScriptValue &object, WheelEvent& event);
+void wheelEventFromScriptValue(const QScriptValue& object, WheelEvent& event);
 
 #endif // __hifi_EventTypes_h__

libraries/shared/src/RegisteredMetaTypes.cpp

@@ -15,6 +15,7 @@ void registerMetaTypes(QScriptEngine* engine) {
     qScriptRegisterMetaType(engine, vec2toScriptValue, vec2FromScriptValue);
     qScriptRegisterMetaType(engine, quatToScriptValue, quatFromScriptValue);
     qScriptRegisterMetaType(engine, xColorToScriptValue, xColorFromScriptValue);
+    qScriptRegisterMetaType(engine, pickRayToScriptValue, pickRayFromScriptValue);
 }
 
 QScriptValue vec3toScriptValue(QScriptEngine* engine, const glm::vec3 &vec3) {
@@ -73,3 +74,28 @@ void xColorFromScriptValue(const QScriptValue &object, xColor& color) {
     color.blue = object.property("blue").toVariant().toInt();
 }
 
+QScriptValue pickRayToScriptValue(QScriptEngine* engine, const PickRay& pickRay) {
+    QScriptValue obj = engine->newObject();
+    QScriptValue origin = vec3toScriptValue(engine, pickRay.origin);
+    obj.setProperty("origin", origin);
+    QScriptValue direction = vec3toScriptValue(engine, pickRay.direction);
+    obj.setProperty("direction", direction);
+    return obj;
+
+}
+
+void pickRayFromScriptValue(const QScriptValue& object, PickRay& pickRay) {
+    QScriptValue originValue = object.property("origin");
+    if (originValue.isValid()) {
+        pickRay.origin.x = originValue.property("x").toVariant().toFloat();
+        pickRay.origin.y = originValue.property("y").toVariant().toFloat();
+        pickRay.origin.z = originValue.property("z").toVariant().toFloat();
+    }
+    QScriptValue directionValue = object.property("direction");
+    if (directionValue.isValid()) {
+        pickRay.direction.x = directionValue.property("x").toVariant().toFloat();
+        pickRay.direction.y = directionValue.property("y").toVariant().toFloat();
+        pickRay.direction.z = directionValue.property("z").toVariant().toFloat();
+    }
+}
+

libraries/shared/src/RegisteredMetaTypes.h

@@ -22,7 +22,6 @@ Q_DECLARE_METATYPE(glm::vec2)
 Q_DECLARE_METATYPE(glm::quat)
 Q_DECLARE_METATYPE(xColor)
 
-
 void registerMetaTypes(QScriptEngine* engine);
 
 QScriptValue vec3toScriptValue(QScriptEngine* engine, const glm::vec3 &vec3);
@@ -37,4 +36,15 @@ void quatFromScriptValue(const QScriptValue &object, glm::quat& quat);
 QScriptValue xColorToScriptValue(QScriptEngine* engine, const xColor& color);
 void xColorFromScriptValue(const QScriptValue &object, xColor& color);
 
+class PickRay {
+public:
+    PickRay() : origin(0), direction(0)  { }; 
+    glm::vec3 origin;
+    glm::vec3 direction;
+};
+Q_DECLARE_METATYPE(PickRay)
+QScriptValue pickRayToScriptValue(QScriptEngine* engine, const PickRay& pickRay);
+void pickRayFromScriptValue(const QScriptValue& object, PickRay& pickRay);
+
+
 #endif