svn merge -r 37212:37306 https://svn.blender.org/svnroot/bf-blender/trunk/blender
authorBenoit Bolsee <benoit.bolsee@online.be>
Tue, 7 Jun 2011 21:20:25 +0000 (21:20 +0000)
committerBenoit Bolsee <benoit.bolsee@online.be>
Tue, 7 Jun 2011 21:20:25 +0000 (21:20 +0000)
1  2 
source/blender/blenkernel/intern/customdata.c
source/blender/blenkernel/intern/object.c
source/blender/blenloader/intern/readfile.c
source/blender/makesdna/DNA_scene_types.h
source/blender/makesrna/intern/rna_scene.c

index bffb4c3852a9c95a78a5bbe3ef5e7591f382123c,45faba8439c728e72e16643cadf511d771edbb9f..57a7c917fa35218e945a7e9d1d352b7a45762bcc
@@@ -540,7 -540,7 +540,7 @@@ static void layerInterp_mdisps(void **s
                                float face_u, face_v, crn_u, crn_v;
  
                                mdisp_apply_weight(S, dst_corners, x, y, st, crn_weight, &face_u, &face_v);
-                               crn = mdisp_rot_face_to_crn(src_corners, st, face_u, face_v, &crn_u, &crn_v);
+                               crn = mdisp_rot_face_to_quad_crn(src_corners, st, face_u, face_v, &crn_u, &crn_v);
  
                                old_mdisps_bilinear((*out), &s->disps[crn*side*side], side, crn_u, crn_v);
                                mdisp_flip_disp(crn, dst_corners, axis_x, axis_y, *out);
@@@ -844,8 -844,7 +844,8 @@@ static const LayerTypeInfo LAYERTYPEINF
         layerSwap_mcol, layerDefault_mcol},
         {sizeof(MCol)*4, "MCol", 4, "TexturedCol", NULL, NULL, layerInterp_mcol,
         layerSwap_mcol, layerDefault_mcol},
 -      {sizeof(float)*3, "", 0, NULL, NULL, NULL, NULL, NULL, NULL}
 +      {sizeof(float)*3, "", 0, NULL, NULL, NULL, NULL, NULL, NULL},
 +      {sizeof(MRecast), "MRecast", 1,"Recast",NULL,NULL,NULL,NULL}
  };
  
  static const char *LAYERTYPENAMES[CD_NUMTYPES] = {
        /*   5-9 */ "CDMTFace", "CDMCol", "CDOrigIndex", "CDNormal", "CDFlags",
        /* 10-14 */ "CDMFloatProperty", "CDMIntProperty","CDMStringProperty", "CDOrigSpace", "CDOrco",
        /* 15-19 */ "CDMTexPoly", "CDMLoopUV", "CDMloopCol", "CDTangent", "CDMDisps",
 -      /* 20-23 */"CDWeightMCol", "CDIDMCol", "CDTextureMCol", "CDClothOrco"
 +      /* 20-24 */"CDWeightMCol", "CDIDMCol", "CDTextureMCol", "CDClothOrco", "CDMRecast"
  };
  
  const CustomDataMask CD_MASK_BAREMESH =
  const CustomDataMask CD_MASK_MESH =
        CD_MASK_MVERT | CD_MASK_MEDGE | CD_MASK_MFACE |
        CD_MASK_MSTICKY | CD_MASK_MDEFORMVERT | CD_MASK_MTFACE | CD_MASK_MCOL |
 -      CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_PROP_STR | CD_MASK_MDISPS;
 +      CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_PROP_STR | CD_MASK_MDISPS | CD_MASK_RECAST;
  const CustomDataMask CD_MASK_EDITMESH =
        CD_MASK_MSTICKY | CD_MASK_MDEFORMVERT | CD_MASK_MTFACE |
 -      CD_MASK_MCOL|CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_PROP_STR | CD_MASK_MDISPS;
 +      CD_MASK_MCOL|CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_PROP_STR | CD_MASK_MDISPS | CD_MASK_RECAST;
  const CustomDataMask CD_MASK_DERIVEDMESH =
        CD_MASK_MSTICKY | CD_MASK_MDEFORMVERT | CD_MASK_MTFACE |
        CD_MASK_MCOL | CD_MASK_ORIGINDEX | CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_CLOTH_ORCO |
 -      CD_MASK_PROP_STR | CD_MASK_ORIGSPACE | CD_MASK_ORCO | CD_MASK_TANGENT | CD_MASK_WEIGHT_MCOL;
 +      CD_MASK_PROP_STR | CD_MASK_ORIGSPACE | CD_MASK_ORCO | CD_MASK_TANGENT | CD_MASK_WEIGHT_MCOL | CD_MASK_RECAST;
  const CustomDataMask CD_MASK_BMESH = 
        CD_MASK_MSTICKY | CD_MASK_MDEFORMVERT | CD_MASK_PROP_FLT | CD_MASK_PROP_INT | CD_MASK_PROP_STR;
  const CustomDataMask CD_MASK_FACECORNERS =
index 90c5ac149a13ab8b229fb02f785f80f13c422ef7,16fa16054674ead7fd31cd523b752747695b0499..189f2735aa8405330bc78ccdb71321a30c6bf2be
@@@ -1078,7 -1078,6 +1078,7 @@@ Object *add_only_object(int type, cons
        ob->state=1;
        /* ob->pad3 == Contact Processing Threshold */
        ob->m_contactProcessingThreshold = 1.;
 +      ob->obstacleRad = 1.;
        
        /* NT fluid sim defaults */
        ob->fluidsimFlag = 0;
@@@ -2388,24 -2387,42 +2388,42 @@@ void object_set_dimensions(Object *ob, 
  void minmax_object(Object *ob, float *min, float *max)
  {
        BoundBox bb;
-       Mesh *me;
-       Curve *cu;
        float vec[3];
        int a;
+       short change= FALSE;
        
        switch(ob->type) {
-               
        case OB_CURVE:
        case OB_FONT:
        case OB_SURF:
-               cu= ob->data;
-               
-               if(cu->bb==NULL) tex_space_curve(cu);
-               bb= *(cu->bb);
-               
-               for(a=0; a<8; a++) {
-                       mul_m4_v3(ob->obmat, bb.vec[a]);
-                       DO_MINMAX(bb.vec[a], min, max);
+               {
+                       Curve *cu= ob->data;
+                       if(cu->bb==NULL) tex_space_curve(cu);
+                       bb= *(cu->bb);
+                       for(a=0; a<8; a++) {
+                               mul_m4_v3(ob->obmat, bb.vec[a]);
+                               DO_MINMAX(bb.vec[a], min, max);
+                       }
+                       change= TRUE;
+               }
+               break;
+       case OB_LATTICE:
+               {
+                       Lattice *lt= ob->data;
+                       BPoint *bp= lt->def;
+                       int u, v, w;
+                       for(w=0; w<lt->pntsw; w++) {
+                               for(v=0; v<lt->pntsv; v++) {
+                                       for(u=0; u<lt->pntsu; u++, bp++) {
+                                               mul_v3_m4v3(vec, ob->obmat, bp->vec);
+                                               DO_MINMAX(vec, min, max);
+                                       }
+                               }
+                       }
+                       change= TRUE;
                }
                break;
        case OB_ARMATURE:
                                mul_v3_m4v3(vec, ob->obmat, pchan->pose_tail);
                                DO_MINMAX(vec, min, max);
                        }
-                       break;
+                       change= TRUE;
                }
-               /* no break, get_mesh will give NULL and it passes on to default */
+               break;
        case OB_MESH:
-               me= get_mesh(ob);
-               
-               if(me) {
-                       bb = *mesh_get_bb(ob);
-                       
-                       for(a=0; a<8; a++) {
-                               mul_m4_v3(ob->obmat, bb.vec[a]);
-                               DO_MINMAX(bb.vec[a], min, max);
+               {
+                       Mesh *me= get_mesh(ob);
+                       if(me) {
+                               bb = *mesh_get_bb(ob);
+                               for(a=0; a<8; a++) {
+                                       mul_m4_v3(ob->obmat, bb.vec[a]);
+                                       DO_MINMAX(bb.vec[a], min, max);
+                               }
+                               change= TRUE;
                        }
                }
-               if(min[0] < max[0] ) break;
-               
-               /* else here no break!!!, mesh can be zero sized */
-               
-       default:
+               break;
+       }
+       if(change == FALSE) {
                DO_MINMAX(ob->obmat[3], min, max);
  
                copy_v3_v3(vec, ob->obmat[3]);
                copy_v3_v3(vec, ob->obmat[3]);
                sub_v3_v3(vec, ob->size);
                DO_MINMAX(vec, min, max);
-               break;
        }
  }
  
index 384c2782d36be5f727ba02e5e6b2d91bd7244967,6f0400d5764f58a9cd2c5e2766916742bd7df674..53d4ceec4e1f3c77ac038f7cb738835b5df68144
@@@ -1723,7 -1723,6 +1723,6 @@@ static void lib_link_fcurves(FileData *
  static void direct_link_fmodifiers(FileData *fd, ListBase *list)
  {
        FModifier *fcm;
-       int a;
        
        for (fcm= list->first; fcm; fcm= fcm->next) {
                /* relink general data */
                                data->coefficients= newdataadr(fd, data->coefficients);
  
                                if(fd->flags & FD_FLAGS_SWITCH_ENDIAN) {
+                                       unsigned int a;
                                        for(a = 0; a < data->arraysize; a++)
                                                SWITCH_INT(data->coefficients[a]);
                                }
@@@ -3828,11 -3828,6 +3828,11 @@@ static void lib_link_object(FileData *f
                                        arma->target= newlibadr(fd, ob->id.lib, arma->target);
                                        arma->subtarget= newlibadr(fd, ob->id.lib, arma->subtarget);
                                }
 +                              else if(act->type==ACT_STEERING) {
 +                                      bSteeringActuator *steeringa = act->data; 
 +                                      steeringa->target = newlibadr(fd, ob->id.lib, steeringa->target);
 +                                      steeringa->navmesh = newlibadr(fd, ob->id.lib, steeringa->navmesh);
 +                              }
                                act= act->next;
                        }
                        
@@@ -11462,23 -11457,6 +11462,23 @@@ static void do_versions(FileData *fd, L
                }
        }
        
 +      // init facing axis property of steering actuators
 +      {                                       
 +              Object *ob;
 +              for(ob = main->object.first; ob; ob = ob->id.next) {
 +                      bActuator *act;
 +                      for(act= ob->actuators.first; act; act= act->next) {
 +                              if(act->type==ACT_STEERING) {
 +                                      bSteeringActuator* stact = act->data;
 +                                      if (stact->facingaxis==0)
 +                                      {
 +                                              stact->facingaxis=1;
 +                                      }                                               
 +                              }
 +                      }
 +              }
 +      }
 +      
        if (main->versionfile < 256) {
                bScreen *sc;
                ScrArea *sa;
                }
        }
        
 +      //set defaults for obstacle avoidance, recast data
 +      {
 +              Scene *sce;
 +              for(sce = main->scene.first; sce; sce = sce->id.next)
 +              {
 +                      if (sce->gm.levelHeight == 0.f)
 +                              sce->gm.levelHeight = 2.f;
 +
 +                      if(sce->gm.recastData.cellsize == 0.0f)
 +                              sce->gm.recastData.cellsize = 0.3f;
 +                      if(sce->gm.recastData.cellheight == 0.0f)
 +                              sce->gm.recastData.cellheight = 0.2f;
 +                      if(sce->gm.recastData.agentmaxslope == 0.0f)
 +                              sce->gm.recastData.agentmaxslope = M_PI/4;
 +                      if(sce->gm.recastData.agentmaxclimb == 0.0f)
 +                              sce->gm.recastData.agentmaxclimb = 0.9f;
 +                      if(sce->gm.recastData.agentheight == 0.0f)
 +                              sce->gm.recastData.agentheight = 2.0f;
 +                      if(sce->gm.recastData.agentradius == 0.0f)
 +                              sce->gm.recastData.agentradius = 0.6f;
 +                      if(sce->gm.recastData.edgemaxlen == 0.0f)
 +                              sce->gm.recastData.edgemaxlen = 12.0f;
 +                      if(sce->gm.recastData.edgemaxerror == 0.0f)
 +                              sce->gm.recastData.edgemaxerror = 1.3f;
 +                      if(sce->gm.recastData.regionminsize == 0.0f)
 +                              sce->gm.recastData.regionminsize = 50.f;
 +                      if(sce->gm.recastData.regionmergesize == 0.0f)
 +                              sce->gm.recastData.regionmergesize = 20.f;
 +                      if(sce->gm.recastData.vertsperpoly<3)
 +                              sce->gm.recastData.vertsperpoly = 6;
 +                      if(sce->gm.recastData.detailsampledist == 0.0f)
 +                              sce->gm.recastData.detailsampledist = 6.0f;
 +                      if(sce->gm.recastData.detailsamplemaxerror == 0.0f)
 +                              sce->gm.recastData.detailsamplemaxerror = 1.0f;
 +              }                       
 +      }
 +      
        /* WATCH IT!!!: pointers from libdata have not been converted yet here! */
        /* WATCH IT 2!: Userdef struct init has to be in editors/interface/resources.c! */
  
@@@ -12603,11 -12544,6 +12603,11 @@@ static void expand_object(FileData *fd
                        bArmatureActuator *arma= act->data;
                        expand_doit(fd, mainvar, arma->target);
                }
 +              else if(act->type==ACT_STEERING) {
 +                      bSteeringActuator *sta= act->data;
 +                      expand_doit(fd, mainvar, sta->target);
 +                      expand_doit(fd, mainvar, sta->navmesh);
 +              }
                act= act->next;
        }
  
index fb9b4f01b97ca160a860af872e63479c51fa82ef,70e90cfc71399a60f4620f64fb8f5af5977ab1f4..ccc306e777b4276680ce8c5d8326a538579bba0e
@@@ -432,23 -432,6 +432,23 @@@ typedef struct GameFraming 
  #define SCE_GAMEFRAMING_EXTEND 1
  #define SCE_GAMEFRAMING_SCALE  2
  
 +typedef struct RecastData
 +{
 +      float cellsize;
 +      float cellheight;
 +      float agentmaxslope;
 +      float agentmaxclimb;
 +      float agentheight;
 +      float agentradius;
 +      float edgemaxlen;
 +      float edgemaxerror;
 +      float regionminsize;
 +      float regionmergesize;
 +      int vertsperpoly;
 +      float detailsampledist;
 +      float detailsamplemaxerror;
 +} RecastData;
 +
  typedef struct GameData {
  
        /* physics (it was in world)*/
         * bit 3: (gameengine): Activity culling is enabled.
         * bit 5: (gameengine) : enable Bullet DBVT tree for view frustrum culling
        */
 -      short mode, flag, matmode, pad[3];
 +      short mode, flag, matmode, pad[2];
        short occlusionRes;             /* resolution of occlusion Z buffer in pixel */
        short physicsEngine;
        short ticrate, maxlogicstep, physubstep, maxphystep;
 +      short obstacleSimulation;
 +      float levelHeight;
 +
  
        /*  standalone player */
        struct GameFraming framing;
        struct GameDome dome;
        short stereoflag, stereomode, xsch, ysch; //xsch and ysch used for backwards compat.
        float eyeseparation, pad1;
 +      RecastData recastData;
  } GameData;
  
  #define STEREO_NOSTEREO               1
  #define WOPHY_ODE             4
  #define WOPHY_BULLET  5
  
 +/* obstacleSimulation */
 +#define OBSTSIMULATION_NONE           0
 +#define OBSTSIMULATION_TOI_rays               1
 +#define OBSTSIMULATION_TOI_cells      2
 +
  /* GameData.flag */
  #define GAME_ENABLE_ALL_FRAMES                                (1 << 1)
  #define GAME_SHOW_DEBUG_PROPS                         (1 << 2)
  #define GAME_IGNORE_DEPRECATION_WARNINGS      (1 << 12)
  #define GAME_ENABLE_ANIMATION_RECORD          (1 << 13)
  #define GAME_SHOW_MOUSE                                               (1 << 14)
 +#define GAME_SHOW_OBSTACLE_SIMULATION         (1 << 15)
  #define GAME_GLSL_NO_COLOR_MANAGEMENT         (1 << 15)
  
  /* GameData.matmode */
@@@ -1036,13 -1009,14 +1036,14 @@@ typedef struct Scene 
  #define R_JPEG2K_CINE_PRESET  256
  #define R_JPEG2K_CINE_48FPS           512
  
  /* bake_mode: same as RE_BAKE_xxx defines */
  /* bake_flag: */
  #define R_BAKE_CLEAR          1
  #define R_BAKE_OSA                    2
  #define R_BAKE_TO_ACTIVE      4
  #define R_BAKE_NORMALIZE      8
+ #define R_BAKE_MULTIRES               16
+ #define R_BAKE_LORES_MESH     32
  
  /* bake_normal_space */
  #define R_BAKE_SPACE_CAMERA    0
index b384c91a6b52c89cd6bfb3b9537eefa6d340e137,145a58ecf0f231ca14d699bc8c3a11afcc7ef70d..8018fab3999133b10315a2e28da005c8d832fdb1
@@@ -39,7 -39,6 +39,7 @@@
  #include "DNA_particle_types.h"
  #include "DNA_scene_types.h"
  #include "DNA_userdef_types.h"
 +#include "BLI_math.h"
  
  /* Include for Bake Options */
  #include "RE_pipeline.h"
@@@ -1625,96 -1624,6 +1625,96 @@@ void rna_def_render_layer_common(Struct
        else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
  }
  
 +static void rna_def_scene_game_recast_data(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      srna= RNA_def_struct(brna, "SceneGameRecastData", NULL);
 +      RNA_def_struct_sdna(srna, "RecastData");
 +      RNA_def_struct_nested(brna, srna, "Scene");
 +      RNA_def_struct_ui_text(srna, "Recast Data", "Recast data for a Game datablock");
 +
 +      prop= RNA_def_property(srna, "cell_size", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "cellsize");
 +      RNA_def_property_ui_range(prop, 0.1, 1, 1, 2);
 +      RNA_def_property_ui_text(prop, "Cell Size", "Rasterized cell size");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop= RNA_def_property(srna, "cell_height", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "cellheight");
 +      RNA_def_property_ui_range(prop, 0.1, 1, 1, 2);
 +      RNA_def_property_ui_text(prop, "Cell Height", "Rasterized cell height");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop= RNA_def_property(srna, "agent_height", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "agentheight");
 +      RNA_def_property_ui_range(prop, 0.1, 5, 1, 2);
 +      RNA_def_property_ui_text(prop, "Agent Height", "Minimum height where the agent can still walk");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop= RNA_def_property(srna, "agent_radius", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "agentradius");
 +      RNA_def_property_ui_range(prop, 0.1, 5, 1, 2);
 +      RNA_def_property_ui_text(prop, "Agent Radius", "Radius of the agent");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop= RNA_def_property(srna, "max_climb", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "agentmaxclimb");
 +      RNA_def_property_ui_range(prop, 0.1, 5, 1, 2);
 +      RNA_def_property_ui_text(prop, "Max Climb", "Maximum height between grid cells the agent can climb");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop= RNA_def_property(srna, "max_slope", PROP_FLOAT, PROP_ANGLE);
 +      RNA_def_property_float_sdna(prop, NULL, "agentmaxslope");
 +      RNA_def_property_range(prop, 0, M_PI/2);
 +      RNA_def_property_ui_text(prop, "Max Slope", "Maximum walkable slope angle in degrees");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +
 +      prop= RNA_def_property(srna, "region_min_size", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "regionminsize");
 +      RNA_def_property_ui_range(prop, 0, 150, 1, 2);
 +      RNA_def_property_ui_text(prop, "Min Region Size", "Minimum regions size. Smaller regions will be deleted");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop= RNA_def_property(srna, "region_merge_size", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "regionmergesize");
 +      RNA_def_property_ui_range(prop, 0, 150, 1, 2);
 +      RNA_def_property_ui_text(prop, "Merged Region Size", "Minimum regions size. Smaller regions will be merged");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop= RNA_def_property(srna, "edge_max_len", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "edgemaxlen");
 +      RNA_def_property_ui_range(prop, 0, 50, 1, 2);
 +      RNA_def_property_ui_text(prop, "Max Edge Length", "Maximum contour edge length");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop= RNA_def_property(srna, "edge_max_error", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "edgemaxerror");
 +      RNA_def_property_ui_range(prop, 0.1, 3.0, 1, 2);
 +      RNA_def_property_ui_text(prop, "Max Edge Error", "Maximum distance error from contour to cells");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop= RNA_def_property(srna, "verts_per_poly", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "vertsperpoly");
 +      RNA_def_property_ui_range(prop, 3, 12, 1, 0);
 +      RNA_def_property_ui_text(prop, "Verts Per Poly", "Max number of vertices per polygon");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop= RNA_def_property(srna, "sample_dist", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "detailsampledist");
 +      RNA_def_property_ui_range(prop, 0.0, 16.0, 1, 2);
 +      RNA_def_property_ui_text(prop, "Sample Distance", "Detail mesh sample spacing");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop= RNA_def_property(srna, "sample_max_error", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "detailsamplemaxerror");
 +      RNA_def_property_ui_range(prop, 0.0, 16.0, 1, 2);
 +      RNA_def_property_ui_text(prop, "Max Sample Error", "Detail mesh simplification max sample error");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +}
 +
  static void rna_def_scene_game_data(BlenderRNA *brna)
  {
        StructRNA *srna;
                {GAME_MAT_GLSL, "GLSL", 0, "GLSL", "OpenGL shading language shaders"},
                {0, NULL, 0, NULL, NULL}};
  
 +      static EnumPropertyItem obstacle_simulation_items[] = {
 +              {OBSTSIMULATION_NONE, "NONE", 0, "None", ""},
 +              {OBSTSIMULATION_TOI_rays, "RVO (rays)", 0, "RVO (rays)", ""},
 +              {OBSTSIMULATION_TOI_cells, "RVO (cells)", 0, "RVO (cells)", ""},
 +              {0, NULL, 0, NULL, NULL}};
 +
        srna= RNA_def_struct(brna, "SceneGameData", NULL);
        RNA_def_struct_sdna(srna, "GameData");
        RNA_def_struct_nested(brna, srna, "Scene");
        RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_GLSL_NO_EXTRA_TEX);
        RNA_def_property_ui_text(prop, "GLSL Extra Textures", "Use extra textures like normal or specular maps for GLSL rendering");
        RNA_def_property_update(prop, NC_SCENE|NA_EDITED, "rna_Scene_glsl_update");
 +
 +      /* obstacle simulation */
 +      prop= RNA_def_property(srna, "obstacle_simulation", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "obstacleSimulation");
 +      RNA_def_property_enum_items(prop, obstacle_simulation_items);
 +      RNA_def_property_ui_text(prop, "Obstacle simulation", "Simulation used for obstacle avoidance in the game engine");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop= RNA_def_property(srna, "level_height", PROP_FLOAT, PROP_ACCELERATION);
 +      RNA_def_property_float_sdna(prop, NULL, "levelHeight");
 +      RNA_def_property_range(prop, 0.0f, 200.0f);
 +      RNA_def_property_ui_text(prop, "Level height", "Max difference in heights of obstacles to enable their interaction");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop= RNA_def_property(srna, "show_obstacle_simulation", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", GAME_SHOW_OBSTACLE_SIMULATION);
 +      RNA_def_property_ui_text(prop, "Visualization", "Enable debug visualization for obstacle simulation");
 +
 +      /* Recast Settings */
 +      prop= RNA_def_property(srna, "recast_data", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_flag(prop, PROP_NEVER_NULL);
 +      RNA_def_property_pointer_sdna(prop, NULL, "recastData");
 +      RNA_def_property_struct_type(prop, "SceneGameRecastData");
 +      RNA_def_property_ui_text(prop, "Recast Data", "");
 +
 +      /* Nestled Data  */
 +      rna_def_scene_game_recast_data(brna);
  }
  
  static void rna_def_scene_render_layer(BlenderRNA *brna)
@@@ -2936,6 -2812,14 +2936,14 @@@ static void rna_def_scene_render_data(B
        RNA_def_property_range(prop, 0.0, 1000.0);
        RNA_def_property_ui_text(prop, "Bias", "Bias towards faces further away from the object (in blender units)");
        
+       prop= RNA_def_property(srna, "use_bake_multires", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "bake_flag", R_BAKE_MULTIRES);
+       RNA_def_property_ui_text(prop, "Bake from Multires", "Bake directly from multires object");
+       prop= RNA_def_property(srna, "use_bake_lores_mesh", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "bake_flag", R_BAKE_LORES_MESH);
+       RNA_def_property_ui_text(prop, "Low Resolution Mesh", "Calculate heights against unsubdivided low resolution mesh");
        /* stamp */
        
        prop= RNA_def_property(srna, "use_stamp_time", PROP_BOOLEAN, PROP_NONE);