svn merge -r 31211:31313 https://svn.blender.org/svnroot/bf-blender/trunk/blender
authorJoerg Mueller <nexyon@gmail.com>
Fri, 13 Aug 2010 10:50:29 +0000 (10:50 +0000)
committerJoerg Mueller <nexyon@gmail.com>
Fri, 13 Aug 2010 10:50:29 +0000 (10:50 +0000)
1  2 
release/scripts/op/console_python.py
source/blender/editors/space_logic/logic_window.c
source/blender/python/doc/sphinx_doc_gen.py
source/blender/python/generic/mathutils_matrix.c
source/gameengine/Ketsji/KX_PythonInit.cpp

index bf551a4dc31e9ef11e9da62dc3d02dcc856788c8,918c31cff0464c018140ced58b51270b6b7bdf81..527ca11f8cd78b103d1a27f41d1c88fdf056282c
@@@ -131,7 -131,7 +131,7 @@@ def execute(context)
      is_multiline = False
  
      try:
-         line = line_object.line
+         line = line_object.body
  
          # run the console, "\n" executes a multiline statement
          line_exec = line if line.strip() else "\n"
@@@ -206,15 -206,19 +206,15 @@@ def autocomplete(context)
      scrollback = ""
      scrollback_error = ""
  
 -    if _BPY_MAIN_OWN:
 -        main_mod_back = sys.modules["__main__"]
 -        sys.modules["__main__"] = console._bpy_main_mod
 -
      try:
          current_line = sc.history[-1]
-         line = current_line.line
+         line = current_line.body
  
          # This function isnt aware of the text editor or being an operator
          # just does the autocomp then copy its results back
-         current_line.line, current_line.current_character, scrollback = \
+         current_line.body, current_line.current_character, scrollback = \
              intellisense.expand(
-                 line=current_line.line,
+                 line=current_line.body,
                  cursor=current_line.current_character,
                  namespace=console.locals,
                  private=bpy.app.debug)
          import traceback
          scrollback_error = traceback.format_exc()
  
 -    if _BPY_MAIN_OWN:
 -        sys.modules["__main__"] = main_mod_back
 -
      # Separate automplete output by command prompts
      if scrollback != '':
-         bpy.ops.console.scrollback_append(text=sc.prompt + current_line.line, type='INPUT')
+         bpy.ops.console.scrollback_append(text=sc.prompt + current_line.body, type='INPUT')
  
      # Now we need to copy back the line from blender back into the
      # text editor. This will change when we dont use the text editor
index 12d566a3ab7b4d03d39d700c14a67eb968356f1f,798c7639d7e7bc4de0c61758bf8a2be567734efe..790eac7aa27d88f5a7473317e12d3c1dca9b3a92
@@@ -2530,7 -2530,7 +2530,7 @@@ static short draw_actuatorbuttons(Main 
                        }
  
                        //str = "Scene %t|Load game%x0|Start loaded game%x1|Restart this game%x2|Quit this game %x3";
 -                      str = "Scene %t|Start new game%x0|Restart this game%x2|Quit this game %x3|Save GameLogic.globalDict %x4|Load GameLogic.globalDict %x5";
 +                      str = "Scene %t|Start new game%x0|Restart this game%x2|Quit this game %x3|Save bge.logic.globalDict %x4|Load bge.logic.globalDict %x5";
                        uiDefButS(block, MENU, B_REDR, str, xco+40, yco-24, (width-80), 19, &gma->type, 0.0, 0.0, 0, 0, ""); 
                        
                        yco -= ysize; 
@@@ -3929,7 -3929,7 +3929,7 @@@ static void draw_actuator_filter_2d(uiL
                        split=uiLayoutSplit(layout, 0.75, 1);
                        row= uiLayoutRow(split, 0);
                        uiLayoutSetActive(row, RNA_boolean_get(ptr, "enable_motion_blur")==1);
-                       uiItemR(row, ptr, "motion_blur_value", 0, NULL, 0);
+                       uiItemR(row, ptr, "motion_blur_factor", 0, NULL, 0);
                        uiItemR(split, ptr, "enable_motion_blur", UI_ITEM_R_TOGGLE, NULL, 0);
                        break;
                default: // all other 2D Filters
index 3dd61a32676b0df48ae7ba64443852a1e9f75013,940b5fbcce9e0f131baa70303422df4efc414440..1355d2508a5aa746a398a528d777f916d5bd5044
@@@ -45,6 -45,7 +45,7 @@@ import rna_inf
  reload(rna_info)
  
  # lame, python wont give some access
+ ClassMethodDescriptorType = type(dict.__dict__['fromkeys'])
  MethodDescriptorType = type(dict.get)
  GetSetDescriptorType = type(int.real)
  
@@@ -143,9 -144,7 +144,9 @@@ def pyfunc2sphinx(ident, fw, identifier
  
  
  def py_descr2sphinx(ident, fw, descr, module_name, type_name, identifier):    
 -
 +    if identifier.startswith("_"):
 +        return
 +    
      doc = descr.__doc__
      if not doc:
          doc = undocumented_message(module_name, type_name, identifier)
      if type(descr) == GetSetDescriptorType:
          fw(ident + ".. attribute:: %s\n\n" % identifier)
          write_indented_lines(ident + "   ", fw, doc, False)
-     elif type(descr) == MethodDescriptorType: # GetSetDescriptorType's are not documented yet
+     elif type(descr) in (MethodDescriptorType, ClassMethodDescriptorType):
          write_indented_lines(ident, fw, doc, False)
      else:
-         raise TypeError("type was not GetSetDescriptorType or MethodDescriptorType")
+         raise TypeError("type was not GetSetDescriptorType, MethodDescriptorType or ClassMethodDescriptorType")
  
      write_example_ref(ident, fw, module_name + "." + type_name + "." + identifier)
      fw("\n")
@@@ -270,7 -269,11 +271,11 @@@ def pymodule2sphinx(BASEPATH, module_na
          descr_items = [(key, descr) for key, descr in sorted(value.__dict__.items()) if not key.startswith("__")]
  
          for key, descr in descr_items:
-             if type(descr) == MethodDescriptorType: # GetSetDescriptorType's are not documented yet
+             if type(descr) == ClassMethodDescriptorType:
+                 py_descr2sphinx("   ", fw, descr, module_name, type_name, key)
+         for key, descr in descr_items:
+             if type(descr) == MethodDescriptorType:
                  py_descr2sphinx("   ", fw, descr, module_name, type_name, key)
  
          for key, descr in descr_items:
@@@ -378,7 -381,6 +383,7 @@@ def rna2sphinx(BASEPATH)
  
      fw("   mathutils.rst\n\n")
      fw("   blf.rst\n\n")
 +    fw("   aud.rst\n\n")
      
      # game engine
      fw("===================\n")
      import blf as module
      pymodule2sphinx(BASEPATH, "blf", module, "Font Drawing (blf)")
      del module
 +    
 +    import aud as module
 +    pymodule2sphinx(BASEPATH, "aud", module, "Audio System (aud)")
 +    del module
  
      # game engine
 -    import shutil
 +    from bge import types as module
 +    pymodule2sphinx(BASEPATH, "bge.types", module, "Game Engine bge.types Module")
 +
 +    from bge import logic as module
 +    pymodule2sphinx(BASEPATH, "bge.logic", module, "Game Engine bge.logic Module")
 +
 +    from bge import render as module
 +    pymodule2sphinx(BASEPATH, "bge.render", module, "Game Engine bge.render Module")
 +
 +    from bge import events as module
 +    pymodule2sphinx(BASEPATH, "bge.events", module, "Game Engine bge.events Module")
 +
 +    #import shutil
      # copy2 keeps time/date stamps
 -    shutil.copy2(os.path.join(BASEPATH, "../../../../gameengine/PyDoc/bge.types.rst"), BASEPATH)
 -    shutil.copy2(os.path.join(BASEPATH, "../../../../gameengine/PyDoc/bge.logic.rst"), BASEPATH)
 -    shutil.copy2(os.path.join(BASEPATH, "../../../../gameengine/PyDoc/bge.render.rst"), BASEPATH)
 -    shutil.copy2(os.path.join(BASEPATH, "../../../../gameengine/PyDoc/bge.events.rst"), BASEPATH)
 +    #shutil.copy2(os.path.join(BASEPATH, "../../../../gameengine/PyDoc/bge.types.rst"), BASEPATH)
 +    #shutil.copy2(os.path.join(BASEPATH, "../../../../gameengine/PyDoc/bge.logic.rst"), BASEPATH)
 +    #shutil.copy2(os.path.join(BASEPATH, "../../../../gameengine/PyDoc/bge.render.rst"), BASEPATH)
 +    #shutil.copy2(os.path.join(BASEPATH, "../../../../gameengine/PyDoc/bge.events.rst"), BASEPATH)
  
  
      if 0:
  
      file.close()
  
 -if __name__ == '__main__':
 +def main():
 +    import bpy
      if 'bpy' not in dir():
          print("\nError, this script must run from inside blender2.5")
          print(script_help_msg)
  
      import sys
      sys.exit()
 +
 +if __name__ == '__main__':
 +    main()
index d54ee9a30ec7e700dc02925d1097462312f4a5ae,1ef834b7a3eb80a66090ce75ffa9d5146de04a86..24239e1f54171b596eff8fbe4a12d08a3449ef2b
@@@ -181,6 -181,438 +181,438 @@@ static PyObject *Matrix_new(PyTypeObjec
        return newMatrixObject(matrix, argSize, seqSize, Py_NEW, NULL);
  }
  
+ /*-----------------------CLASS-METHODS----------------------------*/
+ //----------------------------------mathutils.RotationMatrix() ----------
+ //mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
+ static char C_Matrix_Rotation_doc[] =
+ ".. classmethod:: Rotation(angle, size, axis)\n"
+ "\n"
+ "   Create a matrix representing a rotation.\n"
+ "\n"
+ "   :arg angle: The angle of rotation desired, in radians.\n"
+ "   :type angle: float\n"
+ "   :arg size: The size of the rotation matrix to construct [2, 4].\n"
+ "   :type size: int\n"
+ "   :arg axis: a string in ['X', 'Y', 'Z'] or a 3D Vector Object (optional when size is 2).\n"
+ "   :type axis: string or :class:`Vector`\n"
+ "   :return: A new rotation matrix.\n"
+ "   :rtype: :class:`Matrix`\n";
+ static PyObject *C_Matrix_Rotation(PyObject *cls, PyObject *args)
+ {
+       VectorObject *vec= NULL;
+       char *axis= NULL;
+       int matSize;
+       float angle = 0.0f;
+       float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+               0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
+       if(!PyArg_ParseTuple(args, "fi|O", &angle, &matSize, &vec)) {
+               PyErr_SetString(PyExc_TypeError, "mathutils.RotationMatrix(angle, size, axis): expected float int and a string or vector\n");
+               return NULL;
+       }
+       if(vec && !VectorObject_Check(vec)) {
+               axis= _PyUnicode_AsString((PyObject *)vec);
+               if(axis==NULL || axis[0]=='\0' || axis[1]!='\0' || axis[0] < 'X' || axis[0] > 'Z') {
+                       PyErr_SetString(PyExc_TypeError, "mathutils.RotationMatrix(): 3rd argument axis value must be a 3D vector or a string in 'X', 'Y', 'Z'\n");
+                       return NULL;
+               }
+               else {
+                       /* use the string */
+                       vec= NULL;
+               }
+       }
+       while (angle<-(Py_PI*2))
+               angle+=(Py_PI*2);
+       while (angle>(Py_PI*2))
+               angle-=(Py_PI*2);
+       
+       if(matSize != 2 && matSize != 3 && matSize != 4) {
+               PyErr_SetString(PyExc_AttributeError, "mathutils.RotationMatrix(): can only return a 2x2 3x3 or 4x4 matrix\n");
+               return NULL;
+       }
+       if(matSize == 2 && (vec != NULL)) {
+               PyErr_SetString(PyExc_AttributeError, "mathutils.RotationMatrix(): cannot create a 2x2 rotation matrix around arbitrary axis\n");
+               return NULL;
+       }
+       if((matSize == 3 || matSize == 4) && (axis == NULL) && (vec == NULL)) {
+               PyErr_SetString(PyExc_AttributeError, "mathutils.RotationMatrix(): please choose an axis of rotation for 3d and 4d matrices\n");
+               return NULL;
+       }
+       if(vec) {
+               if(vec->size != 3) {
+                       PyErr_SetString(PyExc_AttributeError, "mathutils.RotationMatrix(): the vector axis must be a 3D vector\n");
+                       return NULL;
+               }
+               
+               if(!BaseMath_ReadCallback(vec))
+                       return NULL;
+               
+       }
+       /* check for valid vector/axis above */
+       if(vec) {
+               axis_angle_to_mat3( (float (*)[3])mat,vec->vec, angle);
+       }
+       else if(matSize == 2) {
+               //2D rotation matrix
+               mat[0] = (float) cos (angle);
+               mat[1] = (float) sin (angle);
+               mat[2] = -((float) sin(angle));
+               mat[3] = (float) cos(angle);
+       } else if(strcmp(axis, "X") == 0) {
+               //rotation around X
+               mat[0] = 1.0f;
+               mat[4] = (float) cos(angle);
+               mat[5] = (float) sin(angle);
+               mat[7] = -((float) sin(angle));
+               mat[8] = (float) cos(angle);
+       } else if(strcmp(axis, "Y") == 0) {
+               //rotation around Y
+               mat[0] = (float) cos(angle);
+               mat[2] = -((float) sin(angle));
+               mat[4] = 1.0f;
+               mat[6] = (float) sin(angle);
+               mat[8] = (float) cos(angle);
+       } else if(strcmp(axis, "Z") == 0) {
+               //rotation around Z
+               mat[0] = (float) cos(angle);
+               mat[1] = (float) sin(angle);
+               mat[3] = -((float) sin(angle));
+               mat[4] = (float) cos(angle);
+               mat[8] = 1.0f;
+       }
+       else {
+               /* should never get here */
+               PyErr_SetString(PyExc_AttributeError, "mathutils.RotationMatrix(): unknown error\n");
+               return NULL;
+       }
+       if(matSize == 4) {
+               //resize matrix
+               mat[10] = mat[8];
+               mat[9] = mat[7];
+               mat[8] = mat[6];
+               mat[7] = 0.0f;
+               mat[6] = mat[5];
+               mat[5] = mat[4];
+               mat[4] = mat[3];
+               mat[3] = 0.0f;
+       }
+       //pass to matrix creation
+       return newMatrixObject(mat, matSize, matSize, Py_NEW, (PyTypeObject *)cls);
+ }
+ static char C_Matrix_Translation_doc[] =
+ ".. classmethod:: Translation(vector)\n"
+ "\n"
+ "   Create a matrix representing a translation.\n"
+ "\n"
+ "   :arg vector: The translation vector.\n"
+ "   :type vector: :class:`Vector`\n"
+ "   :return: An identity matrix with a translation.\n"
+ "   :rtype: :class:`Matrix`\n";
+ static PyObject *C_Matrix_Translation(PyObject *cls, VectorObject * vec)
+ {
+       float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+               0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
+       
+       if(!VectorObject_Check(vec)) {
+               PyErr_SetString(PyExc_TypeError, "mathutils.TranslationMatrix(): expected vector\n");
+               return NULL;
+       }
+       if(vec->size != 3 && vec->size != 4) {
+               PyErr_SetString(PyExc_TypeError, "mathutils.TranslationMatrix(): vector must be 3D or 4D\n");
+               return NULL;
+       }
+       
+       if(!BaseMath_ReadCallback(vec))
+               return NULL;
+       
+       //create a identity matrix and add translation
+       unit_m4((float(*)[4]) mat);
+       mat[12] = vec->vec[0];
+       mat[13] = vec->vec[1];
+       mat[14] = vec->vec[2];
+       return newMatrixObject(mat, 4, 4, Py_NEW, (PyTypeObject *)cls);
+ }
+ //----------------------------------mathutils.ScaleMatrix() -------------
+ //mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
+ static char C_Matrix_Scale_doc[] =
+ ".. classmethod:: Scale(factor, size, axis)\n"
+ "\n"
+ "   Create a matrix representing a scaling.\n"
+ "\n"
+ "   :arg factor: The factor of scaling to apply.\n"
+ "   :type factor: float\n"
+ "   :arg size: The size of the scale matrix to construct [2, 4].\n"
+ "   :type size: int\n"
+ "   :arg axis: Direction to influence scale. (optional).\n"
+ "   :type axis: :class:`Vector`\n"
+ "   :return: A new scale matrix.\n"
+ "   :rtype: :class:`Matrix`\n";
+ static PyObject *C_Matrix_Scale(PyObject *cls, PyObject *args)
+ {
+       VectorObject *vec = NULL;
+       float norm = 0.0f, factor;
+       int matSize, x;
+       float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+               0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
+       if(!PyArg_ParseTuple(args, "fi|O!", &factor, &matSize, &vector_Type, &vec)) {
+               PyErr_SetString(PyExc_TypeError, "mathutils.ScaleMatrix(): expected float int and optional vector\n");
+               return NULL;
+       }
+       if(matSize != 2 && matSize != 3 && matSize != 4) {
+               PyErr_SetString(PyExc_AttributeError, "mathutils.ScaleMatrix(): can only return a 2x2 3x3 or 4x4 matrix\n");
+               return NULL;
+       }
+       if(vec) {
+               if(vec->size > 2 && matSize == 2) {
+                       PyErr_SetString(PyExc_AttributeError, "mathutils.ScaleMatrix(): please use 2D vectors when scaling in 2D\n");
+                       return NULL;
+               }
+               
+               if(!BaseMath_ReadCallback(vec))
+                       return NULL;
+               
+       }
+       if(vec == NULL) {       //scaling along axis
+               if(matSize == 2) {
+                       mat[0] = factor;
+                       mat[3] = factor;
+               } else {
+                       mat[0] = factor;
+                       mat[4] = factor;
+                       mat[8] = factor;
+               }
+       } else { //scaling in arbitrary direction
+               //normalize arbitrary axis
+               for(x = 0; x < vec->size; x++) {
+                       norm += vec->vec[x] * vec->vec[x];
+               }
+               norm = (float) sqrt(norm);
+               for(x = 0; x < vec->size; x++) {
+                       vec->vec[x] /= norm;
+               }
+               if(matSize == 2) {
+                       mat[0] = 1 +((factor - 1) *(vec->vec[0] * vec->vec[0]));
+                       mat[1] =((factor - 1) *(vec->vec[0] * vec->vec[1]));
+                       mat[2] =((factor - 1) *(vec->vec[0] * vec->vec[1]));
+                       mat[3] = 1 + ((factor - 1) *(vec->vec[1] * vec->vec[1]));
+               } else {
+                       mat[0] = 1 + ((factor - 1) *(vec->vec[0] * vec->vec[0]));
+                       mat[1] =((factor - 1) *(vec->vec[0] * vec->vec[1]));
+                       mat[2] =((factor - 1) *(vec->vec[0] * vec->vec[2]));
+                       mat[3] =((factor - 1) *(vec->vec[0] * vec->vec[1]));
+                       mat[4] = 1 + ((factor - 1) *(vec->vec[1] * vec->vec[1]));
+                       mat[5] =((factor - 1) *(vec->vec[1] * vec->vec[2]));
+                       mat[6] =((factor - 1) *(vec->vec[0] * vec->vec[2]));
+                       mat[7] =((factor - 1) *(vec->vec[1] * vec->vec[2]));
+                       mat[8] = 1 + ((factor - 1) *(vec->vec[2] * vec->vec[2]));
+               }
+       }
+       if(matSize == 4) {
+               //resize matrix
+               mat[10] = mat[8];
+               mat[9] = mat[7];
+               mat[8] = mat[6];
+               mat[7] = 0.0f;
+               mat[6] = mat[5];
+               mat[5] = mat[4];
+               mat[4] = mat[3];
+               mat[3] = 0.0f;
+       }
+       //pass to matrix creation
+       return newMatrixObject(mat, matSize, matSize, Py_NEW, (PyTypeObject *)cls);
+ }
+ //----------------------------------mathutils.OrthoProjectionMatrix() ---
+ //mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
+ static char C_Matrix_OrthoProjection_doc[] =
+ ".. classmethod:: OrthoProjection(plane, size, axis)\n"
+ "\n"
+ "   Create a matrix to represent an orthographic projection.\n"
+ "\n"
+ "   :arg plane: Can be any of the following: ['X', 'Y', 'XY', 'XZ', 'YZ', 'R'], where a single axis is for a 2D matrix and 'R' requires axis is given.\n"
+ "   :type plane: string\n"
+ "   :arg size: The size of the projection matrix to construct [2, 4].\n"
+ "   :type size: int\n"
+ "   :arg axis: Arbitrary perpendicular plane vector (optional).\n"
+ "   :type axis: :class:`Vector`\n"
+ "   :return: A new projection matrix.\n"
+ "   :rtype: :class:`Matrix`\n";
+ static PyObject *C_Matrix_OrthoProjection(PyObject *cls, PyObject *args)
+ {
+       VectorObject *vec = NULL;
+       char *plane;
+       int matSize, x;
+       float norm = 0.0f;
+       float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+               0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
+       
+       if(!PyArg_ParseTuple(args, "si|O!", &plane, &matSize, &vector_Type, &vec)) {
+               PyErr_SetString(PyExc_TypeError, "mathutils.OrthoProjectionMatrix(): expected string and int and optional vector\n");
+               return NULL;
+       }
+       if(matSize != 2 && matSize != 3 && matSize != 4) {
+               PyErr_SetString(PyExc_AttributeError,"mathutils.OrthoProjectionMatrix(): can only return a 2x2 3x3 or 4x4 matrix\n");
+               return NULL;
+       }
+       if(vec) {
+               if(vec->size > 2 && matSize == 2) {
+                       PyErr_SetString(PyExc_AttributeError, "mathutils.OrthoProjectionMatrix(): please use 2D vectors when scaling in 2D\n");
+                       return NULL;
+               }
+               
+               if(!BaseMath_ReadCallback(vec))
+                       return NULL;
+               
+       }
+       if(vec == NULL) {       //ortho projection onto cardinal plane
+               if((strcmp(plane, "X") == 0) && matSize == 2) {
+                       mat[0] = 1.0f;
+               } else if((strcmp(plane, "Y") == 0) && matSize == 2) {
+                       mat[3] = 1.0f;
+               } else if((strcmp(plane, "XY") == 0) && matSize > 2) {
+                       mat[0] = 1.0f;
+                       mat[4] = 1.0f;
+               } else if((strcmp(plane, "XZ") == 0) && matSize > 2) {
+                       mat[0] = 1.0f;
+                       mat[8] = 1.0f;
+               } else if((strcmp(plane, "YZ") == 0) && matSize > 2) {
+                       mat[4] = 1.0f;
+                       mat[8] = 1.0f;
+               } else {
+                       PyErr_SetString(PyExc_AttributeError, "mathutils.OrthoProjectionMatrix(): unknown plane - expected: X, Y, XY, XZ, YZ\n");
+                       return NULL;
+               }
+       } else { //arbitrary plane
+               //normalize arbitrary axis
+               for(x = 0; x < vec->size; x++) {
+                       norm += vec->vec[x] * vec->vec[x];
+               }
+               norm = (float) sqrt(norm);
+               for(x = 0; x < vec->size; x++) {
+                       vec->vec[x] /= norm;
+               }
+               if((strcmp(plane, "R") == 0) && matSize == 2) {
+                       mat[0] = 1 - (vec->vec[0] * vec->vec[0]);
+                       mat[1] = -(vec->vec[0] * vec->vec[1]);
+                       mat[2] = -(vec->vec[0] * vec->vec[1]);
+                       mat[3] = 1 - (vec->vec[1] * vec->vec[1]);
+               } else if((strcmp(plane, "R") == 0) && matSize > 2) {
+                       mat[0] = 1 - (vec->vec[0] * vec->vec[0]);
+                       mat[1] = -(vec->vec[0] * vec->vec[1]);
+                       mat[2] = -(vec->vec[0] * vec->vec[2]);
+                       mat[3] = -(vec->vec[0] * vec->vec[1]);
+                       mat[4] = 1 - (vec->vec[1] * vec->vec[1]);
+                       mat[5] = -(vec->vec[1] * vec->vec[2]);
+                       mat[6] = -(vec->vec[0] * vec->vec[2]);
+                       mat[7] = -(vec->vec[1] * vec->vec[2]);
+                       mat[8] = 1 - (vec->vec[2] * vec->vec[2]);
+               } else {
+                       PyErr_SetString(PyExc_AttributeError, "mathutils.OrthoProjectionMatrix(): unknown plane - expected: 'r' expected for axis designation\n");
+                       return NULL;
+               }
+       }
+       if(matSize == 4) {
+               //resize matrix
+               mat[10] = mat[8];
+               mat[9] = mat[7];
+               mat[8] = mat[6];
+               mat[7] = 0.0f;
+               mat[6] = mat[5];
+               mat[5] = mat[4];
+               mat[4] = mat[3];
+               mat[3] = 0.0f;
+       }
+       //pass to matrix creation
+       return newMatrixObject(mat, matSize, matSize, Py_NEW, (PyTypeObject *)cls);
+ }
+ static char C_Matrix_Shear_doc[] =
+ ".. classmethod:: Shear(plane, factor, size)\n"
+ "\n"
+ "   Create a matrix to represent an shear transformation.\n"
+ "\n"
+ "   :arg plane: Can be any of the following: ['X', 'Y', 'XY', 'XZ', 'YZ'], where a single axis is for a 2D matrix.\n"
+ "   :type plane: string\n"
+ "   :arg factor: The factor of shear to apply.\n"
+ "   :type factor: float\n"
+ "   :arg size: The size of the shear matrix to construct [2, 4].\n"
+ "   :type size: int\n"
+ "   :return: A new shear matrix.\n"
+ "   :rtype: :class:`Matrix`\n";
+ static PyObject *C_Matrix_Shear(PyObject *cls, PyObject *args)
+ {
+       int matSize;
+       char *plane;
+       float factor;
+       float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+               0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
+       if(!PyArg_ParseTuple(args, "sfi", &plane, &factor, &matSize)) {
+               PyErr_SetString(PyExc_TypeError,"mathutils.ShearMatrix(): expected string float and int\n");
+               return NULL;
+       }
+       if(matSize != 2 && matSize != 3 && matSize != 4) {
+               PyErr_SetString(PyExc_AttributeError,"mathutils.ShearMatrix(): can only return a 2x2 3x3 or 4x4 matrix\n");
+               return NULL;
+       }
+       if((strcmp(plane, "X") == 0)
+               && matSize == 2) {
+               mat[0] = 1.0f;
+               mat[2] = factor;
+               mat[3] = 1.0f;
+       } else if((strcmp(plane, "Y") == 0) && matSize == 2) {
+               mat[0] = 1.0f;
+               mat[1] = factor;
+               mat[3] = 1.0f;
+       } else if((strcmp(plane, "XY") == 0) && matSize > 2) {
+               mat[0] = 1.0f;
+               mat[4] = 1.0f;
+               mat[6] = factor;
+               mat[7] = factor;
+       } else if((strcmp(plane, "XZ") == 0) && matSize > 2) {
+               mat[0] = 1.0f;
+               mat[3] = factor;
+               mat[4] = 1.0f;
+               mat[5] = factor;
+               mat[8] = 1.0f;
+       } else if((strcmp(plane, "YZ") == 0) && matSize > 2) {
+               mat[0] = 1.0f;
+               mat[1] = factor;
+               mat[2] = factor;
+               mat[4] = 1.0f;
+               mat[8] = 1.0f;
+       } else {
+               PyErr_SetString(PyExc_AttributeError, "mathutils.ShearMatrix(): expected: x, y, xy, xz, yz or wrong matrix size for shearing plane\n");
+               return NULL;
+       }
+       if(matSize == 4) {
+               //resize matrix
+               mat[10] = mat[8];
+               mat[9] = mat[7];
+               mat[8] = mat[6];
+               mat[7] = 0.0f;
+               mat[6] = mat[5];
+               mat[5] = mat[4];
+               mat[4] = mat[3];
+               mat[3] = 0.0f;
+       }
+       //pass to matrix creation
+       return newMatrixObject(mat, matSize, matSize, Py_NEW, (PyTypeObject *)cls);
+ }
  /* assumes rowsize == colsize is checked and the read callback has run */
  static float matrix_determinant(MatrixObject * self)
  {
@@@ -1305,7 -1737,7 +1737,7 @@@ static PyGetSetDef Matrix_getseters[] 
        {"median_scale", (getter)Matrix_getMedianScale, (setter)NULL, "The average scale applied to each axis (readonly).\n\n:type: float", NULL},
        {"is_negative", (getter)Matrix_getIsNegative, (setter)NULL, "True if this matrix results in a negative scale, 3x3 and 4x4 only, (readonly).\n\n:type: bool", NULL},
        {"is_wrapped", (getter)BaseMathObject_getWrapped, (setter)NULL, BaseMathObject_Wrapped_doc, NULL},
 -      {"_owner",(getter)BaseMathObject_getOwner, (setter)NULL, BaseMathObject_Owner_doc, NULL},
 +      {"owner",(getter)BaseMathObject_getOwner, (setter)NULL, BaseMathObject_Owner_doc, NULL},
        {NULL,NULL,NULL,NULL,NULL}  /* Sentinel */
  };
  
@@@ -1326,6 -1758,13 +1758,13 @@@ static struct PyMethodDef Matrix_method
        {"to_quat", (PyCFunction) Matrix_toQuat, METH_NOARGS, Matrix_toQuat_doc},
        {"copy", (PyCFunction) Matrix_copy, METH_NOARGS, Matrix_copy_doc},
        {"__copy__", (PyCFunction) Matrix_copy, METH_NOARGS, Matrix_copy_doc},
+       
+       /* class methods */
+       {"Rotation", (PyCFunction) C_Matrix_Rotation, METH_VARARGS | METH_CLASS, C_Matrix_Rotation_doc},
+       {"Scale", (PyCFunction) C_Matrix_Scale, METH_VARARGS | METH_CLASS, C_Matrix_Scale_doc},
+       {"Shear", (PyCFunction) C_Matrix_Shear, METH_VARARGS | METH_CLASS, C_Matrix_Shear_doc},
+       {"Translation", (PyCFunction) C_Matrix_Translation, METH_O | METH_CLASS, C_Matrix_Translation_doc},
+       {"OrthoProjection", (PyCFunction) C_Matrix_OrthoProjection,  METH_VARARGS | METH_CLASS, C_Matrix_OrthoProjection_doc},
        {NULL, NULL, 0, NULL}
  };
  
index 5aa75a622583ded3cd564bd256ccfce5cffe2b54,3350a59681ba8141c25b36c9923f552e57ab6c05..303890fd6302bdc94d2b8179fdf5b061b54371ef
@@@ -45,10 -45,6 +45,10 @@@ extern "C" 
  
        #include "marshal.h" /* python header for loading/saving dicts */
  }
 +
 +#define WITH_PYTHON
 +#include "AUD_C-API.h"
 +
  #endif
  
  #include "KX_PythonInit.h"
  #include "KX_BlenderSceneConverter.h"
  #include "KX_MeshProxy.h" /* for creating a new library of mesh objects */
  extern "C" {
-       #include "BLO_readfile.h"
+       #include "BKE_idcode.h"
  }
  
  #include "NG_NetworkScene.h" //Needed for sendMessage()
@@@ -266,8 -262,8 +266,8 @@@ static PyObject* gPyRestartGame(PyObjec
  }
  
  static char gPySaveGlobalDict_doc[] =
 -"saveGlobalDict()\n\
 -Saves GameLogic.globalDict to a file";
 +      "saveGlobalDict()\n"
 +      "Saves bge.logic.globalDict to a file";
  
  static PyObject* gPySaveGlobalDict(PyObject*)
  {
  }
  
  static char gPyLoadGlobalDict_doc[] =
 -"LoadGlobalDict()\n\
 -Loads GameLogic.globalDict from a file";
 +      "LoadGlobalDict()\n"
 +      "Loads bge.logic.globalDict from a file";
  
  static PyObject* gPyLoadGlobalDict(PyObject*)
  {
@@@ -379,6 -375,15 +379,6 @@@ static PyObject* gPyGetSpectrum(PyObjec
        return resultlist;
  }
  
 -
 -static PyObject* gPyStopDSP(PyObject*, PyObject* args)
 -{
 -        PyErr_SetString(PyExc_RuntimeError, "no audio device available");
 -        return NULL;
 -      
 -      Py_RETURN_NONE;
 -}
 -
  static PyObject* gPySetLogicTicRate(PyObject*, PyObject* args)
  {
        float ticrate;
@@@ -661,7 -666,7 +661,7 @@@ static PyObject *gLibNew(PyObject*, PyO
                return NULL;
        }
        
-       idcode= BLO_idcode_from_name(group);
+       idcode= BKE_idcode_from_name(group);
        if(idcode==0) {
                PyErr_Format(PyExc_ValueError, "invalid group given \"%s\"", group);
                return NULL;
@@@ -747,6 -752,7 +747,6 @@@ static struct PyMethodDef game_methods[
        {"getRandomFloat",(PyCFunction) gPyGetRandomFloat, METH_NOARGS, (const char *)gPyGetRandomFloat_doc},
        {"setGravity",(PyCFunction) gPySetGravity, METH_O, (const char *)"set Gravitation"},
        {"getSpectrum",(PyCFunction) gPyGetSpectrum, METH_NOARGS, (const char *)"get audio spectrum"},
 -      {"stopDSP",(PyCFunction) gPyStopDSP, METH_VARARGS, (const char *)"stop using the audio dsp (for performance reasons)"},
        {"getMaxLogicFrame", (PyCFunction) gPyGetMaxLogicFrame, METH_NOARGS, (const char *)"Gets the max number of logic frame per render frame"},
        {"setMaxLogicFrame", (PyCFunction) gPySetMaxLogicFrame, METH_VARARGS, (const char *)"Sets the max number of logic frame per render frame"},
        {"getMaxPhysicsFrame", (PyCFunction) gPyGetMaxPhysicsFrame, METH_NOARGS, (const char *)"Gets the max number of physics frame per render frame"},
@@@ -929,6 -935,7 +929,6 @@@ static PyObject* gPyDisableMist(PyObjec
        Py_RETURN_NONE;
  }
  
 -
  static PyObject* gPySetMistStart(PyObject*, PyObject* args)
  {
  
@@@ -1225,7 -1232,7 +1225,7 @@@ static struct PyMethodDef rasterizer_me
  // Initialization function for the module (*must* be called initGameLogic)
  
  static char GameLogic_module_documentation[] =
 -"This is the Python API for the game engine of GameLogic"
 +"This is the Python API for the game engine of bge.logic"
  ;
  
  static char Rasterizer_module_documentation[] =
@@@ -1306,6 -1313,7 +1306,6 @@@ PyObject* initGameLogic(KX_KetsjiEngin
        KX_MACRO_addTypesToDict(d, KX_PROPSENSOR_EXPRESSION, SCA_PropertySensor::KX_PROPSENSOR_EXPRESSION);
  
        /* 3. Constraint actuator                                                  */
 -      /* XXX, TODO NXBGE, move constants names from KX_ACT_CONSTRAINT_foo to KX_CONSTRAINTACT_foo */
        KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_LOCX, KX_ConstraintActuator::KX_ACT_CONSTRAINT_LOCX);
        KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_LOCY, KX_ConstraintActuator::KX_ACT_CONSTRAINT_LOCY);
        KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_LOCZ, KX_ConstraintActuator::KX_ACT_CONSTRAINT_LOCZ);
        KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_ORIX, KX_ConstraintActuator::KX_ACT_CONSTRAINT_ORIX);
        KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_ORIY, KX_ConstraintActuator::KX_ACT_CONSTRAINT_ORIY);
        KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_ORIZ, KX_ConstraintActuator::KX_ACT_CONSTRAINT_ORIZ);
 -      KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_FHPX, KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHPX);
 -      KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_FHPY, KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHPY);
 -      KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_FHPZ, KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHPZ);
 -      KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_FHNX, KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHNX);
 -      KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_FHNY, KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHNY);
 -      KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_FHNZ, KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHNZ);
 -      KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_NORMAL, KX_ConstraintActuator::KX_ACT_CONSTRAINT_NORMAL);
 -      KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_MATERIAL, KX_ConstraintActuator::KX_ACT_CONSTRAINT_MATERIAL);
 -      KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_PERMANENT, KX_ConstraintActuator::KX_ACT_CONSTRAINT_PERMANENT);
 -      KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_DISTANCE, KX_ConstraintActuator::KX_ACT_CONSTRAINT_DISTANCE);
 -      KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_LOCAL, KX_ConstraintActuator::KX_ACT_CONSTRAINT_LOCAL);
 -      KX_MACRO_addTypesToDict(d, KX_ACT_CONSTRAINT_DOROTFH, KX_ConstraintActuator::KX_ACT_CONSTRAINT_DOROTFH);
 +      KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_FHPX, KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHPX);
 +      KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_FHPY, KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHPY);
 +      KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_FHPZ, KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHPZ);
 +      KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_FHNX, KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHNX);
 +      KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_FHNY, KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHNY);
 +      KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_FHNZ, KX_ConstraintActuator::KX_ACT_CONSTRAINT_FHNZ);
 +      KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_NORMAL, KX_ConstraintActuator::KX_ACT_CONSTRAINT_NORMAL);
 +      KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_MATERIAL, KX_ConstraintActuator::KX_ACT_CONSTRAINT_MATERIAL);
 +      KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_PERMANENT, KX_ConstraintActuator::KX_ACT_CONSTRAINT_PERMANENT);
 +      KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_DISTANCE, KX_ConstraintActuator::KX_ACT_CONSTRAINT_DISTANCE);
 +      KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_LOCAL, KX_ConstraintActuator::KX_ACT_CONSTRAINT_LOCAL);
 +      KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_DOROTFH, KX_ConstraintActuator::KX_ACT_CONSTRAINT_DOROTFH);
  
        /* 4. Ipo actuator, simple part                                            */
        KX_MACRO_addTypesToDict(d, KX_IPOACT_PLAY,     KX_IpoActuator::KX_ACT_IPO_PLAY);
        // Check for errors
        if (PyErr_Occurred())
      {
 -              Py_FatalError("can't initialize module GameLogic");
 +              Py_FatalError("can't initialize module bge.logic");
      }
  
        return m;
@@@ -1971,6 -1979,7 +1971,6 @@@ void setupGamePython(KX_KetsjiEngine* k
                PyDict_SetItemString(PyModule_GetDict(*gameLogic), "globalDict", pyGlobalDict); // Same as importing the module.
  
        *gameLogic_keys = PyDict_Keys(PyModule_GetDict(*gameLogic));
 -      PyDict_SetItemString(dictionaryobject, "GameLogic", *gameLogic); // Same as importing the module.
  
        initGameKeys();
        initPythonConstraintBinding();
        initGeometry();
        initBGL();
        initBLF();
 +      AUD_initPython();
        initVideoTexture();
  
        /* could be done a lot more nicely, but for now a quick way to get bge.* working */
 -      PyRun_SimpleString("sys = __import__('sys');mod = sys.modules['bge'] = type(sys)('bge');mod.__dict__.update({'logic':__import__('GameLogic'), 'render':__import__('Rasterizer'), 'events':__import__('GameKeys'), 'constraints':__import__('PhysicsConstraints'), 'types':__import__('GameTypes')})");
 +      PyRun_SimpleString("sys = __import__('sys');mod = sys.modules['bge'] = type(sys)('bge');mod.__dict__.update({'logic':__import__('GameLogic'), 'render':__import__('Rasterizer'), 'events':__import__('GameKeys'), 'constraints':__import__('PhysicsConstraints'), 'types':__import__('GameTypes')});import bge");
  }
  
  static struct PyModuleDef Rasterizer_module_def = {
@@@ -2330,15 -2338,15 +2330,15 @@@ int saveGamePythonConfig( char **marsha
                                memcpy(*marshal_buffer, marshal_cstring, marshal_length);
                                Py_DECREF(pyGlobalDictMarshal);
                        } else {
 -                              printf("Error, GameLogic.globalDict could not be marshal'd\n");
 +                              printf("Error, bge.logic.globalDict could not be marshal'd\n");
                        }
                } else {
 -                      printf("Error, GameLogic.globalDict was removed\n");
 +                      printf("Error, bge.logic.globalDict was removed\n");
                }
                Py_DECREF(gameLogic);
        } else {
                PyErr_Clear();
 -              printf("Error, GameLogic failed to import GameLogic.globalDict will be lost\n");
 +              printf("Error, bge.logic failed to import bge.logic.globalDict will be lost\n");
        }
        return marshal_length;
  }
@@@ -2370,7 -2378,7 +2370,7 @@@ int loadGamePythonConfig(char *marshal_
                        }
                } else {
                        PyErr_Clear();
 -                      printf("Error, GameLogic failed to import GameLogic.globalDict will be lost\n");
 +                      printf("Error, bge.logic failed to import bge.logic.globalDict will be lost\n");
                }       
        }
        return 0;