Revision: 16176
          
http://projects.blender.org/plugins/scmsvn/viewcvs.php?view=rev&root=bf-blender&revision=16176
Author:   genscher
Date:     2008-08-18 16:41:24 +0200 (Mon, 18 Aug 2008)

Log Message:
-----------
a) Forces can be hidden by deflector object now (need to talk with jahka about 
particle integration - should be copy-paste) see 
http://dldw.de/tmp/index.php?file=w2.blend (press play button in timeline and 
change the absorption value ob the cube) b) fixed deflector/collision bug with 
continues physics c) cloth wind/forces uses masses now d) even faster collision 
object gathering e) have fun ;)

Modified Paths:
--------------
    trunk/blender/source/blender/blenkernel/BKE_collision.h
    trunk/blender/source/blender/blenkernel/intern/collision.c
    trunk/blender/source/blender/blenkernel/intern/effect.c
    trunk/blender/source/blender/blenkernel/intern/implicit.c
    trunk/blender/source/blender/blenkernel/intern/modifier.c
    trunk/blender/source/blender/blenkernel/intern/particle_system.c
    trunk/blender/source/blender/makesdna/DNA_modifier_types.h
    trunk/blender/source/blender/src/buttons_object.c

Modified: trunk/blender/source/blender/blenkernel/BKE_collision.h
===================================================================
--- trunk/blender/source/blender/blenkernel/BKE_collision.h     2008-08-18 
14:33:26 UTC (rev 16175)
+++ trunk/blender/source/blender/blenkernel/BKE_collision.h     2008-08-18 
14:41:24 UTC (rev 16176)
@@ -119,8 +119,10 @@
 /////////////////////////////////////////////////
 // used in modifier.c from collision.c
 /////////////////////////////////////////////////
+
 BVHTree *bvhtree_build_from_mvert ( MFace *mfaces, unsigned int numfaces, 
MVert *x, unsigned int numverts, float epsilon );
 void bvhtree_update_from_mvert ( BVHTree * bvhtree, MFace *faces, int 
numfaces, MVert *x, MVert *xnew, int numverts, int moving );
+
 /////////////////////////////////////////////////
 
 LinkNode *BLI_linklist_append_fast ( LinkNode **listp, void *ptr );
@@ -134,6 +136,15 @@
 void interpolateOnTriangle ( float to[3], float v1[3], float v2[3], float 
v3[3], double w1, double w2, double w3 );
 
 /////////////////////////////////////////////////
+// used in effect.c
+/////////////////////////////////////////////////
+CollisionModifierData **get_collisionobjects(Object *self, int *numcollobj);
 
+/////////////////////////////////////////////////
+
+
+
+/////////////////////////////////////////////////
+
 #endif
 

Modified: trunk/blender/source/blender/blenkernel/intern/collision.c
===================================================================
--- trunk/blender/source/blender/blenkernel/intern/collision.c  2008-08-18 
14:33:26 UTC (rev 16175)
+++ trunk/blender/source/blender/blenkernel/intern/collision.c  2008-08-18 
14:41:24 UTC (rev 16176)
@@ -31,10 +31,11 @@
 
 #include "BKE_cloth.h"
 
+#include "DNA_cloth_types.h"
 #include "DNA_group_types.h"
+#include "DNA_mesh_types.h"
 #include "DNA_object_types.h"
-#include "DNA_cloth_types.h"
-#include "DNA_mesh_types.h"
+#include "DNA_object_force.h"
 #include "DNA_scene_types.h"
 
 #include "BKE_DerivedMesh.h"
@@ -1307,10 +1308,35 @@
        for ( base = G.scene->base.first; base; base = base->next )
        {
                coll_ob = base->object;
-               collmd = ( CollisionModifierData * ) modifiers_findByType ( 
coll_ob, eModifierType_Collision );
-       
-               if ( !collmd )
+               
+               if(coll_ob->pd && coll_ob->pd->deflect)
                {
+                       collmd = ( CollisionModifierData * ) 
modifiers_findByType ( coll_ob, eModifierType_Collision );
+               }
+               
+               if ( collmd )
+               {
+                       if(coll_ob == self)
+                               continue;
+                       
+                       if(numobj >= maxobj)
+                       {
+                               // realloc
+                               int oldmax = maxobj;
+                               CollisionModifierData **tmp;
+                               maxobj *= 2;
+                               tmp = MEM_callocN(sizeof(CollisionModifierData 
*)*maxobj, "CollisionObjectsArray");
+                               memcpy(tmp, objs, sizeof(CollisionModifierData 
*)*oldmax);
+                               MEM_freeN(objs);
+                               objs = tmp;
+                               
+                       }
+                       
+                       objs[numobj] = collmd;
+                       numobj++;
+               }
+               else
+               {
                        if ( coll_ob->dup_group )
                        {
                                GroupObject *go;
@@ -1319,9 +1345,13 @@
                                for ( go= group->gobject.first; go; go= 
go->next )
                                {
                                        coll_ob = go->ob;
+                                       collmd = NULL;
+                                       
+                                       if(coll_ob->pd && coll_ob->pd->deflect)
+                                       {
+                                               collmd = ( 
CollisionModifierData * ) modifiers_findByType ( coll_ob, 
eModifierType_Collision );
+                                       }
 
-                                       collmd = ( CollisionModifierData * ) 
modifiers_findByType ( coll_ob, eModifierType_Collision );
-
                                        if ( !collmd )
                                                continue;
 
@@ -1347,27 +1377,6 @@
                                        numobj++;
                                }
                        }
-               }
-               else
-               {
-                       if(coll_ob == self)
-                               continue;
-                       
-                       if(numobj >= maxobj)
-                       {
-                               // realloc
-                               int oldmax = maxobj;
-                               CollisionModifierData **tmp;
-                               maxobj *= 2;
-                               tmp = MEM_callocN(sizeof(CollisionModifierData 
*)*maxobj, "CollisionObjectsArray");
-                               memcpy(tmp, objs, sizeof(CollisionModifierData 
*)*oldmax);
-                               MEM_freeN(objs);
-                               objs = tmp;
-                               
-                       }
-                       
-                       objs[numobj] = collmd;
-                       numobj++;
                }       
        }
        *numcollobj = numobj;
@@ -1484,6 +1493,9 @@
                        BVHTreeOverlap *overlap = NULL;
                        int result = 0;
                        
+                       if(!collmd->bvhtree)
+                               continue;
+                       
                        /* move object to position (step) in time */
                        collision_move_object ( collmd, step + dt, step );
                        

Modified: trunk/blender/source/blender/blenkernel/intern/effect.c
===================================================================
--- trunk/blender/source/blender/blenkernel/intern/effect.c     2008-08-18 
14:33:26 UTC (rev 16175)
+++ trunk/blender/source/blender/blenkernel/intern/effect.c     2008-08-18 
14:41:24 UTC (rev 16176)
@@ -59,6 +59,7 @@
 #include "BKE_armature.h"
 #include "BKE_bad_level_calls.h"
 #include "BKE_blender.h"
+#include "BKE_collision.h"
 #include "BKE_constraint.h"
 #include "BKE_deform.h"
 #include "BKE_depsgraph.h"
@@ -393,8 +394,55 @@
 }
 
 
+static void eff_tri_ray_hit(void *userdata, int index, const BVHTreeRay *ray, 
BVHTreeRayHit *hit)
+{      
+       hit->dist = -1;
+       hit->index = 1;
+}
 
+float eff_calc_visibility(Object *ob, float *co, float *dir, float cur_time)
+{
+       CollisionModifierData **collobjs = NULL;
+       int numcollobj = 0, i;
+       float norm[3], len = 0.0;
+       float visibility = 1.0;
+       
+       collobjs = get_collisionobjects(ob, &numcollobj);
+       
+       if(!collobjs)
+               return 0;
+       
+       VECCOPY(norm, dir);
+       VecMulf(norm, -1.0);
+       len = Normalize(norm);
+       
+       // check all collision objects
+       for(i = 0; i < numcollobj; i++)
+       {
+               CollisionModifierData *collmd = collobjs[i];
+               
+               if(collmd->bvhtree)
+               {
+                       BVHTreeRayHit hit;
+                       
+                       hit.index = -1;
+                       hit.dist = len + FLT_EPSILON;
+                       
+                       
+                       // check if the way is blocked
+                       if(BLI_bvhtree_ray_cast(collmd->bvhtree, co, norm, 
&hit, eff_tri_ray_hit, NULL)>=0)
+                       {
+                               visibility *= MAX2(0.0, MIN2(1.0, 
(1.0-((float)collmd->absorbation)*0.01)));
+                       }
+               }
+       }
+       
+       MEM_freeN(collobjs);
+       
+       return visibility;
+}
 
+
 /*  -------- pdDoEffectors() --------
     generic force/speed system, now used for particles and softbodies
        lb                      = listbase with objects that take part in 
effecting
@@ -430,7 +478,7 @@
        float *obloc;
        
        float distance, vec_to_part[3];
-       float falloff;
+       float falloff, visibility;
 
        /* Cycle through collected objects, get total of (1/(gravity_strength * 
dist^gravity_power)) */
        /* Check for min distance here? (yes would be cool to add that, ton) */
@@ -452,14 +500,19 @@
                distance = VecLength(vec_to_part);
 
                falloff=effector_falloff(pd,ob->obmat[2],vec_to_part);
-
+               
                if(falloff<=0.0f)
+                       continue;
+               
+               visibility = eff_calc_visibility(ob, opco, vec_to_part, 
cur_time);
+               
+               if((visibility*falloff)<=0.0f)
                        ;       /* don't do anything */
                else {
                        float field[3]={0,0,0}, tmp[3];
                        VECCOPY(field, force);
                        
do_physical_effector(pd->forcefield,pd->f_strength,distance,
-                                                               
falloff,pd->f_dist,pd->f_damp,ob->obmat[2],vec_to_part,
+                                                               
visibility*falloff,pd->f_dist,pd->f_damp,ob->obmat[2],vec_to_part,
                                                                
speed,force,pd->flag&PFIELD_PLANAR, pd->rng, pd->f_noise);
                        
                        // for softbody backward compatibility

Modified: trunk/blender/source/blender/blenkernel/intern/implicit.c
===================================================================
--- trunk/blender/source/blender/blenkernel/intern/implicit.c   2008-08-18 
14:33:26 UTC (rev 16175)
+++ trunk/blender/source/blender/blenkernel/intern/implicit.c   2008-08-18 
14:41:24 UTC (rev 16176)
@@ -1405,6 +1405,7 @@
        unsigned int numverts = cloth->numverts;
        LinkNode *search = cloth->springs;
        lfVector *winvec;
+       ClothVertex *verts = cloth->verts;
 
        VECCOPY(gravity, clmd->sim_parms->gravity);
        mul_fvector_S(gravity, gravity, 0.001f); /* scale gravity force */
@@ -1451,7 +1452,6 @@
                        float triunnormal[3]={0,0,0}; // 
not-normalized-triangle normal
                        float tmp[3]={0,0,0};
                        float factor = (mfaces[i].v4) ? 0.25 : 1.0 / 3.0;
-                       factor *= 0.05;
                        
                        // calculate face normal
                        if(mfaces[i].v4)
@@ -1465,24 +1465,24 @@
                        // add wind from v1
                        VECCOPY(tmp, trinormal);
                        VecMulf(tmp, 
calculateVertexWindForce(winvec[mfaces[i].v1], triunnormal));
-                       VECADDS(lF[mfaces[i].v1], lF[mfaces[i].v1], tmp, 
factor);
+                       VECADDS(lF[mfaces[i].v1], lF[mfaces[i].v1], tmp, 
factor*verts[mfaces[i].v1].mass);
                        
                        // add wind from v2
                        VECCOPY(tmp, trinormal);
                        VecMulf(tmp, 
calculateVertexWindForce(winvec[mfaces[i].v2], triunnormal));
-                       VECADDS(lF[mfaces[i].v2], lF[mfaces[i].v2], tmp, 
factor);
+                       VECADDS(lF[mfaces[i].v2], lF[mfaces[i].v2], tmp, 
factor*verts[mfaces[i].v2].mass);
                        
                        // add wind from v3
                        VECCOPY(tmp, trinormal);
                        VecMulf(tmp, 
calculateVertexWindForce(winvec[mfaces[i].v3], triunnormal));
-                       VECADDS(lF[mfaces[i].v3], lF[mfaces[i].v3], tmp, 
factor);
+                       VECADDS(lF[mfaces[i].v3], lF[mfaces[i].v3], tmp, 
factor*verts[mfaces[i].v3].mass);
                        
                        // add wind from v4
                        if(mfaces[i].v4)
                        {
                                VECCOPY(tmp, trinormal);
                                VecMulf(tmp, 
calculateVertexWindForce(winvec[mfaces[i].v4], triunnormal));
-                               VECADDS(lF[mfaces[i].v4], lF[mfaces[i].v4], 
tmp, factor);
+                               VECADDS(lF[mfaces[i].v4], lF[mfaces[i].v4], 
tmp, factor*verts[mfaces[i].v4].mass);
                        }
                }
                del_lfvector(winvec);

Modified: trunk/blender/source/blender/blenkernel/intern/modifier.c
===================================================================
--- trunk/blender/source/blender/blenkernel/intern/modifier.c   2008-08-18 
14:33:26 UTC (rev 16175)
+++ trunk/blender/source/blender/blenkernel/intern/modifier.c   2008-08-18 
14:41:24 UTC (rev 16176)
@@ -5493,7 +5493,7 @@
                
                numverts = dm->getNumVerts ( dm );
                
-               if(current_time > collmd->time)
+               if((current_time > collmd->time)|| 
(BKE_ptcache_get_continue_physics()))
                {       
                        // check if mesh has changed
                        if(collmd->x && (numverts != collmd->numverts))

Modified: trunk/blender/source/blender/blenkernel/intern/particle_system.c
===================================================================
--- trunk/blender/source/blender/blenkernel/intern/particle_system.c    
2008-08-18 14:33:26 UTC (rev 16175)
+++ trunk/blender/source/blender/blenkernel/intern/particle_system.c    
2008-08-18 14:41:24 UTC (rev 16176)
@@ -60,6 +60,7 @@
 #include "BKE_bad_level_calls.h"
 #include "BKE_cdderivedmesh.h"
 #include "BKE_displist.h"
+#include "BKE_effect.h"
 #include "BKE_particle.h"
 #include "BKE_global.h"
 #include "BKE_utildefines.h"

Modified: trunk/blender/source/blender/makesdna/DNA_modifier_types.h
===================================================================
--- trunk/blender/source/blender/makesdna/DNA_modifier_types.h  2008-08-18 
14:33:26 UTC (rev 16175)
+++ trunk/blender/source/blender/makesdna/DNA_modifier_types.h  2008-08-18 
14:41:24 UTC (rev 16176)
@@ -390,7 +390,8 @@
        
        unsigned int numverts;
        unsigned int numfaces;
-       int pad;

@@ Diff output truncated at 10240 characters. @@

_______________________________________________
Bf-blender-cvs mailing list
[email protected]
http://lists.blender.org/mailman/listinfo/bf-blender-cvs

Reply via email to