← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

Viewing changes to source/gameengine/Ketsji/KX_Camera.cpp

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/gameengine/Ketsji/KX_Camera.cpp
38
38
#include "KX_Python.h"
39
39
#include "KX_PyMath.h"
40
40
KX_Camera::KX_Camera(void* sgReplicationInfo,
41
 
                                         SG_Callbacks callbacks,
42
 
                                         const RAS_CameraData& camdata,
43
 
                                         bool frustum_culling,
44
 
                                         bool delete_node)
45
 
                                        :
46
 
                                        KX_GameObject(sgReplicationInfo,callbacks),
47
 
                                        m_camdata(camdata),
48
 
                                        m_dirty(true),
49
 
                                        m_normalized(false),
50
 
                                        m_frustum_culling(frustum_culling),
51
 
                                        m_set_projection_matrix(false),
52
 
                                        m_set_frustum_center(false),
53
 
                                        m_delete_node(delete_node)
 
41
                     SG_Callbacks callbacks,
 
42
                     const RAS_CameraData& camdata,
 
43
                     bool frustum_culling,
 
44
                     bool delete_node)
 
45
    :
 
46
      KX_GameObject(sgReplicationInfo,callbacks),
 
47
      m_camdata(camdata),
 
48
      m_dirty(true),
 
49
      m_normalized(false),
 
50
      m_frustum_culling(frustum_culling),
 
51
      m_set_projection_matrix(false),
 
52
      m_set_frustum_center(false),
 
53
      m_delete_node(delete_node)
54
54
{
55
55
        // setting a name would be nice...
56
56
        m_name = "cam";
67
67
                delete m_pSGNode;
68
68
                m_pSGNode = NULL;
69
69
        }
70
 
}       
 
70
}
71
71
 
72
72
 
73
73
CValue* KX_Camera::GetReplica()
119
119
        //MT_Transform trans;
120
120
        //trans.setBasis(NodeGetWorldOrientation());
121
121
        
122
 
        return NodeGetWorldPosition();          
 
122
        return NodeGetWorldPosition();
123
123
}
124
124
 
125
125
 
593
593
                MT_Point3 center;
594
594
                if (PyVecTo(pycenter, center))
595
595
                {
596
 
                        return PyLong_FromSsize_t(SphereInsideFrustum(center, radius)); /* new ref */
 
596
                        return PyLong_FromLong(SphereInsideFrustum(center, radius)); /* new ref */
597
597
                }
598
598
        }
599
599
 
644
644
                        return NULL;
645
645
        }
646
646
        
647
 
        return PyLong_FromSsize_t(BoxInsideFrustum(box)); /* new ref */
 
647
        return PyLong_FromLong(BoxInsideFrustum(box)); /* new ref */
648
648
}
649
649
 
650
650
KX_PYMETHODDEF_DOC_O(KX_Camera, pointInsideFrustum,
666
666
        MT_Point3 point;
667
667
        if (PyVecTo(value, point))
668
668
        {
669
 
                return PyLong_FromSsize_t(PointInsideFrustum(point)); /* new ref */
 
669
                return PyLong_FromLong(PointInsideFrustum(point)); /* new ref */
670
670
        }
671
671
        
672
672
        PyErr_SetString(PyExc_TypeError, "camera.pointInsideFrustum(point): KX_Camera, expected point argument.");
712
712
        Py_RETURN_NONE;
713
713
}
714
714
 
715
 
PyObject* KX_Camera::pyattr_get_perspective(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 
715
PyObject *KX_Camera::pyattr_get_perspective(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
716
716
{
717
 
        KX_Camera* self= static_cast<KX_Camera*>(self_v);
 
717
        KX_Camera* self = static_cast<KX_Camera*>(self_v);
718
718
        return PyBool_FromLong(self->m_camdata.m_perspective);
719
719
}
720
720
 
721
721
int KX_Camera::pyattr_set_perspective(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
722
722
{
723
 
        KX_Camera* self= static_cast<KX_Camera*>(self_v);
 
723
        KX_Camera* self = static_cast<KX_Camera*>(self_v);
724
724
        int param = PyObject_IsTrue( value );
725
725
        if (param == -1) {
726
726
                PyErr_SetString(PyExc_AttributeError, "camera.perspective = bool: KX_Camera, expected True/False or 0/1");
732
732
        return PY_SET_ATTR_SUCCESS;
733
733
}
734
734
 
735
 
PyObject* KX_Camera::pyattr_get_lens(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 
735
PyObject *KX_Camera::pyattr_get_lens(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
736
736
{
737
 
        KX_Camera* self= static_cast<KX_Camera*>(self_v);
 
737
        KX_Camera* self = static_cast<KX_Camera*>(self_v);
738
738
        return PyFloat_FromDouble(self->m_camdata.m_lens);
739
739
}
740
740
 
741
741
int KX_Camera::pyattr_set_lens(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
742
742
{
743
 
        KX_Camera* self= static_cast<KX_Camera*>(self_v);
 
743
        KX_Camera* self = static_cast<KX_Camera*>(self_v);
744
744
        float param = PyFloat_AsDouble(value);
745
745
        if (param == -1) {
746
746
                PyErr_SetString(PyExc_AttributeError, "camera.lens = float: KX_Camera, expected a float greater then zero");
752
752
        return PY_SET_ATTR_SUCCESS;
753
753
}
754
754
 
755
 
PyObject* KX_Camera::pyattr_get_ortho_scale(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 
755
PyObject *KX_Camera::pyattr_get_ortho_scale(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
756
756
{
757
 
        KX_Camera* self= static_cast<KX_Camera*>(self_v);
 
757
        KX_Camera* self = static_cast<KX_Camera*>(self_v);
758
758
        return PyFloat_FromDouble(self->m_camdata.m_scale);
759
759
}
760
760
 
761
761
int KX_Camera::pyattr_set_ortho_scale(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
762
762
{
763
 
        KX_Camera* self= static_cast<KX_Camera*>(self_v);
 
763
        KX_Camera* self = static_cast<KX_Camera*>(self_v);
764
764
        float param = PyFloat_AsDouble(value);
765
765
        if (param == -1) {
766
766
                PyErr_SetString(PyExc_AttributeError, "camera.ortho_scale = float: KX_Camera, expected a float greater then zero");
772
772
        return PY_SET_ATTR_SUCCESS;
773
773
}
774
774
 
775
 
PyObject* KX_Camera::pyattr_get_near(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 
775
PyObject *KX_Camera::pyattr_get_near(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
776
776
{
777
 
        KX_Camera* self= static_cast<KX_Camera*>(self_v);
 
777
        KX_Camera* self = static_cast<KX_Camera*>(self_v);
778
778
        return PyFloat_FromDouble(self->m_camdata.m_clipstart);
779
779
}
780
780
 
781
781
int KX_Camera::pyattr_set_near(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
782
782
{
783
 
        KX_Camera* self= static_cast<KX_Camera*>(self_v);
 
783
        KX_Camera* self = static_cast<KX_Camera*>(self_v);
784
784
        float param = PyFloat_AsDouble(value);
785
785
        if (param == -1) {
786
786
                PyErr_SetString(PyExc_AttributeError, "camera.near = float: KX_Camera, expected a float greater then zero");
792
792
        return PY_SET_ATTR_SUCCESS;
793
793
}
794
794
 
795
 
PyObject* KX_Camera::pyattr_get_far(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 
795
PyObject *KX_Camera::pyattr_get_far(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
796
796
{
797
 
        KX_Camera* self= static_cast<KX_Camera*>(self_v);
 
797
        KX_Camera* self = static_cast<KX_Camera*>(self_v);
798
798
        return PyFloat_FromDouble(self->m_camdata.m_clipend);
799
799
}
800
800
 
801
801
int KX_Camera::pyattr_set_far(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
802
802
{
803
 
        KX_Camera* self= static_cast<KX_Camera*>(self_v);
 
803
        KX_Camera* self = static_cast<KX_Camera*>(self_v);
804
804
        float param = PyFloat_AsDouble(value);
805
805
        if (param == -1) {
806
806
                PyErr_SetString(PyExc_AttributeError, "camera.far = float: KX_Camera, expected a float greater then zero");
813
813
}
814
814
 
815
815
 
816
 
PyObject* KX_Camera::pyattr_get_use_viewport(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 
816
PyObject *KX_Camera::pyattr_get_use_viewport(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
817
817
{
818
 
        KX_Camera* self= static_cast<KX_Camera*>(self_v);
 
818
        KX_Camera* self = static_cast<KX_Camera*>(self_v);
819
819
        return PyBool_FromLong(self->GetViewport());
820
820
}
821
821
 
822
822
int KX_Camera::pyattr_set_use_viewport(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
823
823
{
824
 
        KX_Camera* self= static_cast<KX_Camera*>(self_v);
 
824
        KX_Camera* self = static_cast<KX_Camera*>(self_v);
825
825
        int param = PyObject_IsTrue( value );
826
826
        if (param == -1) {
827
827
                PyErr_SetString(PyExc_AttributeError, "camera.useViewport = bool: KX_Camera, expected True or False");
832
832
}
833
833
 
834
834
 
835
 
PyObject* KX_Camera::pyattr_get_projection_matrix(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 
835
PyObject *KX_Camera::pyattr_get_projection_matrix(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
836
836
{
837
 
        KX_Camera* self= static_cast<KX_Camera*>(self_v);
 
837
        KX_Camera* self = static_cast<KX_Camera*>(self_v);
838
838
        return PyObjectFrom(self->GetProjectionMatrix()); 
839
839
}
840
840
 
841
841
int KX_Camera::pyattr_set_projection_matrix(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
842
842
{
843
 
        KX_Camera* self= static_cast<KX_Camera*>(self_v);
 
843
        KX_Camera* self = static_cast<KX_Camera*>(self_v);
844
844
        MT_Matrix4x4 mat;
845
845
        if (!PyMatTo(value, mat)) 
846
846
                return PY_SET_ATTR_FAIL;
849
849
        return PY_SET_ATTR_SUCCESS;
850
850
}
851
851
 
852
 
PyObject* KX_Camera::pyattr_get_modelview_matrix(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 
852
PyObject *KX_Camera::pyattr_get_modelview_matrix(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
853
853
{
854
 
        KX_Camera* self= static_cast<KX_Camera*>(self_v);
 
854
        KX_Camera* self = static_cast<KX_Camera*>(self_v);
855
855
        return PyObjectFrom(self->GetModelviewMatrix()); 
856
856
}
857
857
 
858
 
PyObject* KX_Camera::pyattr_get_camera_to_world(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 
858
PyObject *KX_Camera::pyattr_get_camera_to_world(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
859
859
{
860
 
        KX_Camera* self= static_cast<KX_Camera*>(self_v);
 
860
        KX_Camera* self = static_cast<KX_Camera*>(self_v);
861
861
        return PyObjectFrom(self->GetCameraToWorld());
862
862
}
863
863
 
864
 
PyObject* KX_Camera::pyattr_get_world_to_camera(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 
864
PyObject *KX_Camera::pyattr_get_world_to_camera(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
865
865
{
866
 
        KX_Camera* self= static_cast<KX_Camera*>(self_v);
 
866
        KX_Camera* self = static_cast<KX_Camera*>(self_v);
867
867
        return PyObjectFrom(self->GetWorldToCamera()); 
868
868
}
869
869
 
870
870
 
871
 
PyObject* KX_Camera::pyattr_get_INSIDE(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
872
 
{       return PyLong_FromSsize_t(INSIDE); }
873
 
PyObject* KX_Camera::pyattr_get_OUTSIDE(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
874
 
{       return PyLong_FromSsize_t(OUTSIDE); }
875
 
PyObject* KX_Camera::pyattr_get_INTERSECT(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
876
 
{       return PyLong_FromSsize_t(INTERSECT); }
877
 
 
878
 
 
879
 
bool ConvertPythonToCamera(PyObject * value, KX_Camera **object, bool py_none_ok, const char *error_prefix)
 
871
PyObject *KX_Camera::pyattr_get_INSIDE(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 
872
{       return PyLong_FromLong(INSIDE); }
 
873
PyObject *KX_Camera::pyattr_get_OUTSIDE(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 
874
{       return PyLong_FromLong(OUTSIDE); }
 
875
PyObject *KX_Camera::pyattr_get_INTERSECT(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
 
876
{       return PyLong_FromLong(INTERSECT); }
 
877
 
 
878
 
 
879
bool ConvertPythonToCamera(PyObject *value, KX_Camera **object, bool py_none_ok, const char *error_prefix)
880
880
{
881
881
        if (value==NULL) {
882
882
                PyErr_Format(PyExc_TypeError, "%s, python pointer NULL, should never happen", error_prefix);
956
956
                }
957
957
        }
958
958
 
959
 
        GLint viewport[4];
 
959
        const GLint *viewport;
960
960
        GLdouble win[3];
961
961
        GLdouble modelmatrix[16];
962
962
        GLdouble projmatrix[16];
967
967
        m_modelmatrix.getValue(modelmatrix);
968
968
        m_projmatrix.getValue(projmatrix);
969
969
 
970
 
        glGetIntegerv(GL_VIEWPORT, viewport);
 
970
        viewport = KX_GetActiveEngine()->GetCanvas()->GetViewPort();
971
971
 
972
972
        gluProject(vect[0], vect[1], vect[2], modelmatrix, projmatrix, viewport, &win[0], &win[1], &win[2]);
973
973
 
976
976
 
977
977
        vect[1] = 1.0 - vect[1]; //to follow Blender window coordinate system (Top-Down)
978
978
 
979
 
        PyObject* ret = PyTuple_New(2);
 
979
        PyObject *ret = PyTuple_New(2);
980
980
        if (ret) {
981
981
                PyTuple_SET_ITEM(ret, 0, PyFloat_FromDouble(vect[0]));
982
982
                PyTuple_SET_ITEM(ret, 1, PyFloat_FromDouble(vect[1]));
999
999
        MT_Vector3 vect;
1000
1000
        MT_Point3 campos, screenpos;
1001
1001
 
1002
 
        GLint viewport[4];
 
1002
        const GLint *viewport;
1003
1003
        GLdouble win[3];
1004
1004
        GLdouble modelmatrix[16];
1005
1005
        GLdouble projmatrix[16];
1010
1010
        m_modelmatrix.getValue(modelmatrix);
1011
1011
        m_projmatrix.getValue(projmatrix);
1012
1012
 
1013
 
        glGetIntegerv(GL_VIEWPORT, viewport);
 
1013
        viewport = KX_GetActiveEngine()->GetCanvas()->GetViewPort();
1014
1014
 
1015
1015
        vect[0] = x * viewport[2];
1016
1016
        vect[1] = y * viewport[3];
1040
1040
        if (!PyArg_ParseTuple(args,"ddd|s:getScreenRay",&x,&y,&dist,&propName))
1041
1041
                return NULL;
1042
1042
 
1043
 
        PyObject* argValue = PyTuple_New(2);
 
1043
        PyObject *argValue = PyTuple_New(2);
1044
1044
        PyTuple_SET_ITEM(argValue, 0, PyFloat_FromDouble(x));
1045
1045
        PyTuple_SET_ITEM(argValue, 1, PyFloat_FromDouble(y));
1046
1046
 
1048
1048
        {
1049
1049
                Py_DECREF(argValue);
1050
1050
                PyErr_SetString(PyExc_TypeError,
1051
 
                        "Error in getScreenRay. Invalid 2D coordinate. Expected a normalized 2D screen coordinate, a distance and an optional property argument");
 
1051
                                "Error in getScreenRay. Invalid 2D coordinate. "
 
1052
                                "Expected a normalized 2D screen coordinate, "
 
1053
                                "a distance and an optional property argument");
1052
1054
                return NULL;
1053
1055
        }
1054
1056
        Py_DECREF(argValue);
1063
1065
                if (propName)
1064
1066
                        PyTuple_SET_ITEM(argValue, 2, PyUnicode_FromString(propName));
1065
1067
 
1066
 
                PyObject* ret= this->PyrayCastTo(argValue,NULL);
 
1068
                PyObject *ret= this->PyrayCastTo(argValue,NULL);
1067
1069
                Py_DECREF(argValue);
1068
1070
                return ret;
1069
1071
        }