Revision: 47323
http://brlcad.svn.sourceforge.net/brlcad/?rev=47323&view=rev
Author: abhi2011
Date: 2011-10-25 06:28:40 +0000 (Tue, 25 Oct 2011)
Log Message:
-----------
Formatting corrections
Modified Paths:
--------------
brlcad/trunk/src/libged/simulate/simphysics.cpp
brlcad/trunk/src/libged/simulate/simrt.c
brlcad/trunk/src/libged/simulate/simrt.h
brlcad/trunk/src/libged/simulate/simulate.c
brlcad/trunk/src/libged/simulate/simulate.h
brlcad/trunk/src/libged/simulate/simutils.c
Modified: brlcad/trunk/src/libged/simulate/simphysics.cpp
===================================================================
--- brlcad/trunk/src/libged/simulate/simphysics.cpp 2011-10-24 20:31:57 UTC
(rev 47322)
+++ brlcad/trunk/src/libged/simulate/simphysics.cpp 2011-10-25 06:28:40 UTC
(rev 47323)
@@ -92,11 +92,11 @@
for (i=dynamicsWorld->getNumCollisionObjects()-1; i>=0; i--) {
- btCollisionObject* obj = dynamicsWorld->getCollisionObjectArray()[i];
- btRigidBody* body = btRigidBody::upcast(obj);
+ //btCollisionObject* obj = dynamicsWorld->getCollisionObjectArray()[i];
+ //btRigidBody* body = btRigidBody::upcast(obj);
- btVector3 gravity(0,0, 10.0);
- body->applyCentralForce(gravity);
+ //btVector3 gravity(0,0, 10.0);
+ //body->applyCentralForce(gravity);
}
}
@@ -444,10 +444,16 @@
rbA->rb_namep,
rbB->rb_namep);
- generate_force(sim_params, rbA, rbB);
+ /* Generate manifolds using rt */
+ rv = generate_forces(sim_params, rbA, rbB);
+ if (rv != GED_OK) {
+ bu_log("nearphase_callback: ERROR while creating forces between %s &
%s\n",
+ rbA->rb_namep, rbB->rb_namep);
+ }
+}
- // Only dispatch the Bullet collision information if physics should
continue
- dispatcher.defaultNearCallback(collisionPair, dispatcher, dispatchInfo);
+// Only dispatch the Bullet collision information if physics should continue
+dispatcher.defaultNearCallback(collisionPair, dispatcher, dispatchInfo);
}
Modified: brlcad/trunk/src/libged/simulate/simrt.c
===================================================================
--- brlcad/trunk/src/libged/simulate/simrt.c 2011-10-24 20:31:57 UTC (rev
47322)
+++ brlcad/trunk/src/libged/simulate/simrt.c 2011-10-25 06:28:40 UTC (rev
47323)
@@ -32,8 +32,13 @@
* progression of a ray, the y needs to be increased gradually, no need to
* record other info
*/
-struct overlap overlap_list;
-struct hit_reg hit_list;
+#define MAX_OVERLAPS 4
+#define MAX_HITS 4
+
+int num_hits = 0;
+int num_overlaps = 0;
+struct overlap overlap_list[MAX_OVERLAPS];
+struct hit_reg hit_list[MAX_HITS];
struct rayshot_results rt_result;
@@ -63,36 +68,9 @@
int
cleanup_lists(void)
{
- struct overlap *ovp, *ovp_free;
- struct hit_reg *hrp, *hrp_free;
+ num_hits = 0;
+ num_overlaps = 0;
- /* Free all nodes of overlap circularly linked list */
- if (overlap_list.forw != &overlap_list) {
- ovp = overlap_list.forw;
- while (ovp != &overlap_list) {
- ovp_free = ovp;
- ovp = ovp->forw;
- bu_free(ovp_free, "cleanup_lists:free overlap_list");
-
- }
- }
-
- /* Free all nodes of hit region circularly linked list */
- if (hit_list.forw != &hit_list) {
- hrp = hit_list.forw;
- while (hrp != &hit_list) {
- hrp_free = hrp;
- hrp = hrp->forw;
- bu_free(hrp_free, "cleanup_lists:hit_list");
- }
- }
-
- overlap_list.forw = overlap_list.backw = &overlap_list;
- hit_list.forw = hit_list.backw = &hit_list;
-
- overlap_list.index = 0;
- hit_list.index = 0;
-
return GED_OK;
}
@@ -127,11 +105,24 @@
int
+exists_normal(vect_t n)
+{
+ int i;
+ vect_t a;
+ for(i=0; i<rt_result.num_normals; i++){
+ VMOVE(a, rt_result.normals[i]);
+ if(VEQUAL(a, n))
+ return 1;
+ }
+
+ return 0;
+}
+
+
+int
if_hit(struct application *ap, struct partition *part_headp, struct seg
*UNUSED(segs))
{
- struct hit_reg *new_hit_regp;
-
/* iterating over partitions, this will keep track of the current
* partition we're working on.
*/
@@ -155,15 +146,18 @@
/* will contain normal vector where ray exits geometry */
vect_t onormal;
+ int i = 0;
+
/* iterate over each partition until we get back to the head.
* each partition corresponds to a specific homogeneous region of
* material.
*/
for (pp=part_headp->pt_forw; pp != part_headp; pp = pp->pt_forw) {
- new_hit_regp = (struct hit_reg *) bu_malloc(sizeof(struct hit_reg),
"new_hit_regp");
- if(new_hit_regp){
+ if(num_hits < MAX_HITS){
+ i = num_hits;
+
/* print the name of the region we hit as well as the name of
* the primitives encountered on entry and exit.
*/
@@ -174,11 +168,11 @@
/* Insert solid data into list node */
if(pp->pt_regionp->reg_name[0] == '/')
- new_hit_regp->reg_name = (pp->pt_regionp->reg_name) + 1;
+ hit_list[i].reg_name = (pp->pt_regionp->reg_name) + 1;
else
- new_hit_regp->reg_name = pp->pt_regionp->reg_name;
- new_hit_regp->in_stp = pp->pt_inseg->seg_stp;
- new_hit_regp->out_stp = pp->pt_outseg->seg_stp;
+ hit_list[i].reg_name = pp->pt_regionp->reg_name;
+ hit_list[i].in_stp = pp->pt_inseg->seg_stp;
+ hit_list[i].out_stp = pp->pt_outseg->seg_stp;
/* entry hit point, so we type less */
hitp = pp->pt_inhit;
@@ -225,10 +219,10 @@
bu_log(" c2=%g\n", cur.crv_c2);*/
/* Insert the data about the input point into the list */
- VMOVE(new_hit_regp->in_point, in_pt);
- VMOVE(new_hit_regp->in_normal, inormal);
- new_hit_regp->in_dist = hitp->hit_dist;
- new_hit_regp->cur = cur;
+ VMOVE(hit_list[i].in_point, in_pt);
+ VMOVE(hit_list[i].in_normal, inormal);
+ hit_list[i].in_dist = hitp->hit_dist;
+ hit_list[i].cur = cur;
/* exit point, so we type less */
hitp = pp->pt_outhit;
@@ -252,18 +246,19 @@
VPRINT( " Onormal", onormal);*/
/* Insert the data about the input point into the list */
- VMOVE(new_hit_regp->out_point, out_pt);
- VMOVE(new_hit_regp->out_normal, onormal);
- new_hit_regp->out_dist = hitp->hit_dist;
+ VMOVE(hit_list[i].out_point, out_pt);
+ VMOVE(hit_list[i].out_normal, onormal);
+ hit_list[i].out_dist = hitp->hit_dist;
/* Insert the new hit region into the list of hit regions */
- new_hit_regp->forw = hit_list.forw;
- new_hit_regp->backw = &hit_list;
- new_hit_regp->forw->backw = new_hit_regp;
- hit_list.forw = new_hit_regp;
- new_hit_regp->index = (new_hit_regp->forw->index) + 1;
+ hit_list[i].index = i;
+ num_hits++;
+
}
+ else{
+ bu_log("if_hit: WARNING Skipping hit region as maximum hits
reached");
+ }
}
return HIT;
@@ -282,41 +277,54 @@
if_overlap(struct application *ap, struct partition *pp, struct region *reg1,
struct region *reg2, struct partition *InputHdp)
{
- struct overlap *new_ovlp;
+ int i = 0;
bu_log("if_overlap: OVERLAP between %s and %s", reg1->reg_name,
reg2->reg_name);
- new_ovlp = (struct overlap *) bu_malloc(sizeof(struct overlap),
"new_ovlp");
- if(new_ovlp){
- new_ovlp->ap = ap;
- new_ovlp->pp = pp;
- new_ovlp->reg1 = reg1;
- new_ovlp->reg2 = reg2;
- new_ovlp->in_dist = pp->pt_inhit->hit_dist;
- new_ovlp->out_dist = pp->pt_outhit->hit_dist;
- VJOIN1(new_ovlp->in_point, ap->a_ray.r_pt, pp->pt_inhit->hit_dist,
+
+ if(num_overlaps < MAX_OVERLAPS){
+ i = num_overlaps;
+ overlap_list[i].ap = ap;
+ overlap_list[i].pp = pp;
+ overlap_list[i].reg1 = reg1;
+ overlap_list[i].reg2 = reg2;
+ overlap_list[i].in_dist = pp->pt_inhit->hit_dist;
+ overlap_list[i].out_dist = pp->pt_outhit->hit_dist;
+ VJOIN1(overlap_list[i].in_point, ap->a_ray.r_pt, pp->pt_inhit->hit_dist,
ap->a_ray.r_dir);
- VJOIN1(new_ovlp->out_point, ap->a_ray.r_pt, pp->pt_outhit->hit_dist,
+ VJOIN1(overlap_list[i].out_point, ap->a_ray.r_pt,
pp->pt_outhit->hit_dist,
ap->a_ray.r_dir);
- /* Insert the new overlap into the list of overlaps */
- new_ovlp->forw = overlap_list.forw;
- new_ovlp->backw = &overlap_list;
- new_ovlp->forw->backw = new_ovlp;
- overlap_list.forw = new_ovlp;
- new_ovlp->index = (new_ovlp->forw->index) + 1;
- if(new_ovlp->reg1->reg_name[0] == '/')
- new_ovlp->reg1->reg_name++;
+ /* compute the normal vector at the exit point, flipping the
+ * normal if necessary.
+ */
+ RT_HIT_NORMAL(overlap_list[i].in_normal, pp->pt_inhit,
+ pp->pt_inseg->seg_stp, &(ap->a_ray), pp->pt_inflip);
- if(new_ovlp->reg2->reg_name[0] == '/')
- new_ovlp->reg2->reg_name++;
+
+ /* compute the normal vector at the exit point, flipping the
+ * normal if necessary.
+ */
+ RT_HIT_NORMAL(overlap_list[i].out_normal, pp->pt_outhit,
+ pp->pt_outseg->seg_stp, &(ap->a_ray), pp->pt_outflip);
+
+ overlap_list[i].index = i;
+ num_overlaps++;
+
+ bu_log("if_overlap: Set overlap %d, in_normal: %f,%f,%f , out_normal:
%f,%f,%f",
+ overlap_list[i].index,
+ V3ARGS(overlap_list[i].in_normal),
+ V3ARGS(overlap_list[i].out_normal) );
}
+ else{
+ bu_log("if_overlap: WARNING Skipping overlap region as maximum overlaps
reached");
+ }
bu_log("if_overlap: Entering at (%f,%f,%f) at distance of %f",
- V3ARGS(new_ovlp->in_point), new_ovlp->in_dist);
+ V3ARGS(overlap_list[i].in_point), overlap_list[i].in_dist);
bu_log("if_overlap: Exiting at (%f,%f,%f) at distance of %f",
- V3ARGS(new_ovlp->out_point), new_ovlp->out_dist);
+ V3ARGS(overlap_list[i].out_point), overlap_list[i].out_dist);
return rt_defoverlap (ap, pp, reg1, reg2, InputHdp);
@@ -374,7 +382,8 @@
/* Add all the sim objects to the rt_i */
for (rb = sim_params->head_node; rb != NULL; rb = rb->next) {
if (rt_gettree(sim_params->rtip, rb->rb_namep) < 0)
- bu_log("generate_manifolds: Failed to load geometry for [%s]\n",
rb->rb_namep);
+ bu_log("generate_manifolds: Failed to load geometry for [%s]\n",
+ rb->rb_namep);
else
bu_log("generate_manifolds: Added [%s] to raytracer\n",
rb->rb_namep);
}
@@ -387,12 +396,9 @@
bu_log("Simulation objects bounding box (%f, %f, %f):(%f,%f,%f)",
V3ARGS(sim_params->rtip->mdl_min),
V3ARGS(sim_params->rtip->mdl_max));
- overlap_list.forw = overlap_list.backw = &overlap_list;
- hit_list.forw = hit_list.backw = &hit_list;
+ num_hits = 0;
+ num_overlaps = 0;
- overlap_list.index = 0;
- hit_list.index = 0;
-
return GED_OK;
}
@@ -406,19 +412,34 @@
rt_result.xr_min_y_in[Y] = MAX_FASTF;
rt_result.xr_max_y_in[Y] = -MAX_FASTF;
+ VSETALL(rt_result.force, SMALL_FASTF);
+ rt_result.num_normals = 0;
+
return GED_OK;
}
-/**
- * Traverse the hit list and overlap list, drawing the ray segments
- */
+void
+clear_bad_chars(struct bu_vls *vp)
+{
+ unsigned int i = 0;
+ for(i = vp->vls_offset; i<(vp->vls_offset + vp->vls_len); i++){
+ if( vp->vls_str[i] == '-' ||
+ vp->vls_str[i] == '/')
+ vp->vls_str[i] = 'R';
+
+ }
+}
+
+
int
traverse_xray_lists(struct simulation_params *sim_params,
point_t pt, point_t dir)
{
- struct overlap *ovp;
+ int i;
+ vect_t a;
+
/*struct hit_reg *hrp;*/
struct bu_vls reg_vls = BU_VLS_INIT_ZERO;
@@ -428,66 +449,77 @@
/* Draw all the overlap regions : lines are added for overlap segments
* to help visual debugging
*/
- if (overlap_list.forw != &overlap_list) {
+ for(i=0; i<num_overlaps; i++){
+ bu_vls_sprintf(®_vls, "ray_overlap_%s_%s_%d_%f_%f_%f_%f_%f_%f",
+ overlap_list[i].reg1->reg_name,
+ overlap_list[i].reg2->reg_name,
+ overlap_list[i].index,
+ V3ARGS(pt), V3ARGS(dir));
- ovp = overlap_list.forw;
- while (ovp != &overlap_list) {
+ clear_bad_chars(®_vls);
- bu_vls_sprintf(®_vls, "ray_overlap_%s_%s_%d_%f_%f_%f_%f_%f_%f",
- ovp->reg1->reg_name,
- ovp->reg2->reg_name,
- ovp->index,
- V3ARGS(pt), V3ARGS(dir));
- line(sim_params->gedp, bu_vls_addr(®_vls),
- ovp->in_point,
- ovp->out_point,
- 0, 210, 0);
+ line(sim_params->gedp, bu_vls_addr(®_vls),
+ overlap_list[i].in_point,
+ overlap_list[i].out_point,
+ 0, 210, 0);
- add_to_comb(sim_params->gedp, sim_params->sim_comb_name,
bu_vls_addr(®_vls));
+ bu_log("traverse_xray_lists: %s", bu_vls_addr(®_vls));
+ add_to_comb(sim_params->gedp, sim_params->sim_comb_name,
bu_vls_addr(®_vls));
- /* Fill up the result structure */
- /* The min x in the direction of the ray where it hit an overlap */
- if(ovp->in_point[X] < rt_result.xr_min_x[X]){
- VMOVE(rt_result.xr_min_x, ovp->in_point);
- }
+ /* Fill up the result structure */
- /* The max x in the direction of the ray where it hit an overlap,
- * could be on a different ray from above
- */
- if((ovp->out_point[X] > rt_result.xr_max_x[X])){
- VMOVE(rt_result.xr_max_x, ovp->out_point);
- }
+ /* The min x in the direction of the ray where it hit an overlap */
+ if(overlap_list[i].in_point[X] < rt_result.xr_min_x[X]){
+ VMOVE(rt_result.xr_min_x, overlap_list[i].in_point);
+ }
- /* The min y where the x rays encountered overlap */
- if(ovp->in_point[Y] < rt_result.xr_min_y_in[Y]){
- VMOVE(rt_result.xr_min_y_in, ovp->in_point);
- VMOVE(rt_result.xr_min_y_out, ovp->out_point);
- }
+ /* The max x in the direction of the ray where it hit an overlap,
+ * could be on a different ray from above
+ */
+ if((overlap_list[i].out_point[X] > rt_result.xr_max_x[X])){
+ VMOVE(rt_result.xr_max_x, overlap_list[i].out_point);
+ }
- /* The max y for the same */
- if(ovp->in_point[Y] > rt_result.xr_max_y_in[Y]){
- VMOVE(rt_result.xr_max_y_in, ovp->in_point);
- VMOVE(rt_result.xr_max_y_out, ovp->out_point);
- }
+ /* The min y where the x rays encountered overlap */
+ if(overlap_list[i].in_point[Y] < rt_result.xr_min_y_in[Y]){
+ VMOVE(rt_result.xr_min_y_in, overlap_list[i].in_point);
+ VMOVE(rt_result.xr_min_y_out, overlap_list[i].out_point);
+ }
- /* The min z where the x rays encountered overlap */
- if(ovp->in_point[Y] < rt_result.xr_min_z_in[Z]){
- /* Not need currently, may be removed when z-rays are shot */
- }
+ /* The max y for the same */
+ if(overlap_list[i].in_point[Y] > rt_result.xr_max_y_in[Y]){
+ VMOVE(rt_result.xr_max_y_in, overlap_list[i].in_point);
+ VMOVE(rt_result.xr_max_y_out, overlap_list[i].out_point);
+ }
- /* The max z for the same */
- if(ovp->in_point[Y] > rt_result.xr_max_z_in[Z]){
- /* Not need currently, may be removed when z-rays are shot */
- }
+ /* The min z where the x rays encountered overlap */
+ if(overlap_list[i].in_point[Y] < rt_result.xr_min_z_in[Z]){
+ /* Not need currently, may be removed when z-rays are shot */
+ }
+ /* The max z for the same */
+ if(overlap_list[i].in_point[Y] > rt_result.xr_max_z_in[Z]){
+ /* Not need currently, may be removed when z-rays are shot */
+ }
- ovp = ovp->forw;
+ /* Add force from entry normal */
+ if(!exists_normal(overlap_list[i].in_normal)){
+ VREVERSE(a, overlap_list[i].in_normal);
+ VADD2(rt_result.force, rt_result.force, a);
+ }
+ /* Add force from exit normal */
+ if(!exists_normal(overlap_list[i].out_normal)){
+ VREVERSE(a, overlap_list[i].out_normal);
+ VADD2(rt_result.force, rt_result.force, a);
+ }
- }
+ bu_log("traverse_lists : force = %f,%f,%f",
+ V3ARGS(rt_result.force));
+
}
/* Draw all the hit regions : not really needed to be visualized */
@@ -529,8 +561,6 @@
/* Set direction as straight down X-axis */
VSET(r_dir, 1.0, 0.0, 0.0);
- startz = overlap_min[Z];
- starty = overlap_min[Y];
bu_log("Querying overlap between %s & %s",
current_manifold->rbA->rb_namep,
@@ -539,16 +569,29 @@
/* Determine the width along z axis */
VSUB2(diff, overlap_max, overlap_min);
+ startz = overlap_min[Z] - TOL;
+
/* Is it thinner than TOLerance ? */
/*if(diff[Z] < TOL){*/
/* Yep , so shoot rays only in a single plane in the middle of the overlap
region*/
- startz = overlap_min[Z] + diff[Z]*0.5;
+ startz += diff[Z]*0.5;
/* The overlap region is too thin for generating 4 contacts points, 2 will
do */
- for(z=startz; z<overlap_max[Z]; z += TOL){
- for(y=starty; y<(overlap_max[Y]+TOL); y += TOL){
+ for(z=startz; z<overlap_max[Z]; ){
+ z += TOL;
+ if(z > overlap_max[Z])
+ z = overlap_max[Z];
+
+ starty = overlap_min[Y] - TOL;
+
+ for(y=starty; y<overlap_max[Y]; ){
+
+ y += TOL;
+ if(y > overlap_max[Y])
+ y = overlap_max[Y];
+
/* Shooting towards lower x, so start from max x outside of overlap
box */
VSET(r_pt, overlap_min[X], y, z);
@@ -562,15 +605,17 @@
*/
traverse_xray_lists(sim_params, r_pt, r_dir);
- print_rayshot_results();
+ //print_rayshot_results();
/* Cleanup the overlap and hit lists and free memory */
cleanup_lists();
+ bu_log("Last y ray fired from y = %f, overlap_max[Y]=%f", y,
overlap_max[Y]);
+
}
- bu_log("Last y ray fired from z=%f, y=%f , overlap_max[Z]=%f,
overlap_max[Y]=%f",
- z, y, overlap_max[Z], overlap_max[Y]);
+ bu_log("Last z ray fired from z = %f, overlap_max[Z]=%f", z,
overlap_max[Z]);
+
}
/*}*/
@@ -582,67 +627,24 @@
int
create_contact_pairs(struct sim_manifold *mf, vect_t overlap_min, vect_t
overlap_max)
{
- vect_t /*a, b,*/ c;
- /* int i; */
-
-
/* Prepare the overlap prim name */
- bu_log("create_contact_pairs : between %s & %s",
- mf->rbA->rb_namep, mf->rbB->rb_namep);
+ bu_log("create_contact_pairs : between %s & %s (%f,%f,%f), (%f,%f,%f)",
+ mf->rbA->rb_namep, mf->rbB->rb_namep,
+ V3ARGS(overlap_min), V3ARGS(overlap_max));
- /* Determine if an arb4 needs to be generated using x/y/z diff. */
- mf->num_contacts = 4;
+ bu_log("create_contact_pairs : force = %f,%f,%f", V3ARGS(rt_result.force));
+ VUNITIZE(rt_result.force);
+ bu_log("create_contact_pairs : force = %f,%f,%f", V3ARGS(rt_result.force));
- /* VMOVE(mf->contacts[0].ptA, rt_result.xr_min_y_in);
- VMOVE(mf->contacts[1].ptA, rt_result.xr_min_y_out);
-
- VMOVE(mf->contacts[1].ptB, rt_result.xr_max_y_in);
- VMOVE(mf->contacts[0].ptB, rt_result.xr_max_y_out);
-
- for(i=0; i< mf->num_contacts; i++){
- bu_log("create_contact_pairs : %d, %s(%f, %f, %f) -- %s(%f, %f, %f)",
- i, mf->rbA->rb_namep, V3ARGS(mf->contacts[i].ptA),
- mf->rbB->rb_namep, V3ARGS(mf->contacts[i].ptB));
- }
-
- VSUB2(a, mf->contacts[1].ptB, mf->contacts[1].ptA);
- VSUB2(b, mf->contacts[0].ptA, mf->contacts[1].ptB);*/
-
- /* Get the normals */
- /* VCROSS(c, a, b);
- VUNITIZE(c);
- bu_log("create_contact_pairs : Normal got as %f,%f, %f",
- V3ARGS(c));*/
-
- VSET(mf->contacts[0].normalWorldOnB, 0, 0, 1.0000);
- VSET(mf->contacts[1].normalWorldOnB, 0, 0, 1.0000);
- VSET(mf->contacts[2].normalWorldOnB, 0, 0, 1.0000);
- VSET(mf->contacts[3].normalWorldOnB, 0, 0, 1.0000);
-
-
- /* Get penetration depth */
- VSUB2(c, overlap_max, overlap_min);
- mf->contacts[0].depth = c[Z];
- mf->contacts[1].depth = c[Z];
- mf->contacts[2].depth = c[Z];
- mf->contacts[3].depth = c[Z];
- bu_log("create_contact_pairs : Penetration depth set to %f",
mf->contacts[0].depth );
-
- VSET(mf->contacts[0].ptB, 1.000000, 1.000000, overlap_min[Z]);
- VSET(mf->contacts[1].ptB, 1.000000, 0.000000, overlap_min[Z]);
- VSET(mf->contacts[2].ptB, 0.000000, 0.000000, overlap_min[Z]);
- VSET(mf->contacts[3].ptB, 0.000000, 1.000000, overlap_min[Z]);
-
-
return GED_OK;
}
int
-generate_force(struct simulation_params *sim_params,
- struct rigid_body *rbA,
- struct rigid_body *rbB)
+generate_forces(struct simulation_params *sim_params,
+ struct rigid_body *rbA,
+ struct rigid_body *rbB)
{
/* The manifold between rbA & rbB will be stored in B */
struct sim_manifold *rt_mf = &(rbB->rt_manifold);
@@ -671,13 +673,13 @@
add_to_comb(sim_params->gedp, sim_params->sim_comb_name,
bu_vls_addr(&overlap_name));
/* Initialize the rayshot results structure, has to be done for each
manifold */
- /*init_rayshot_results();*/
+ init_rayshot_results();
/* Shoot rays right here as the pair of rigid_body ptrs are known,
* TODO: ignore volumes already shot
*/
- /*shoot_x_rays(rt_mf, sim_params, overlap_min, overlap_max);*/
+ shoot_x_rays(rt_mf, sim_params, overlap_min, overlap_max);
/* shoot_y_rays(); */
Modified: brlcad/trunk/src/libged/simulate/simrt.h
===================================================================
--- brlcad/trunk/src/libged/simulate/simrt.h 2011-10-24 20:31:57 UTC (rev
47322)
+++ brlcad/trunk/src/libged/simulate/simrt.h 2011-10-25 06:28:40 UTC (rev
47323)
@@ -34,36 +34,40 @@
extern "C" {
#endif
- /* System Headers */
+/* System Headers */
#include <stdlib.h>
#include <ctype.h>
#include <math.h>
#include <string.h>
- /* Public Headers */
+/* Public Headers */
#include "vmath.h"
#include "db.h"
#include "bu.h"
- /* Private Headers */
+/* Private Headers */
#include "../ged_private.h"
#include "simulate.h"
#include "simutils.h"
- /* Rays will be at least this far apart when shot through the overlap
regions
- * This is also the contact threshold for Bullet (0.04 cm if units are in
meters)
- * Overlaps regions smaller than this will have only a single plane of
rays slicing the
- * region in half, generating manifolds in a plane.
- */
+/* Rays will be at least this far apart when shot through the overlap regions
+ * This is also the contact threshold for Bullet (0.04 cm if units are in
meters)
+ * Overlaps regions smaller than this will have only a single plane of rays
slicing the
+ * region in half, generating manifolds in a plane.
+ */
#define TOL 0.04
+/*
+ * Maximum normals allowed to be detected by ray shots
+ */
+#define MAX_NORMALS 10
- /*
- * This structure is a single node of a circularly linked list
- * of overlap regions: similar to the one in nirt/usrfrmt.h
- */
- struct overlap {
+/*
+ * This structure is a single node of a circularly linked list
+ * of overlap regions: similar to the one in nirt/usrfrmt.h
+ */
+struct overlap {
int index;
struct application *ap;
struct partition *pp;
@@ -73,16 +77,18 @@
fastf_t out_dist;
point_t in_point;
point_t out_point;
+ vect_t in_normal;
+ vect_t out_normal;
struct overlap *forw;
struct overlap *backw;
- };
+};
- /*
- * This structure is a single node of a circularly linked list
- * of hit regions, similar to struct hit from raytrace.h
- */
- struct hit_reg {
+/*
+ * This structure is a single node of a circularly linked list
+ * of hit regions, similar to struct hit from raytrace.h
+ */
+struct hit_reg {
int index;
struct application *ap;
struct partition *pp;
@@ -99,14 +105,18 @@
int hit_surfno; /**< @brief solid-specific
surface indicator */
struct hit_reg *forw;
struct hit_reg *backw;
- };
+};
- /**
- * This structure contains the results of analyzing an overlap
volume(among 2
- * regions), through shooting rays
- */
- struct rayshot_results{
+/**
+ * This structure contains the results of analyzing an overlap volume(among 2
+ * regions), through shooting rays
+ */
+struct rayshot_results{
+ vect_t force;
+ vect_t normals[MAX_NORMALS];
+ int num_normals;
+
/* Results of shooting rays towards -ve x-axis : xr means x rays */
point_t xr_min_x; /* the min X found while shooting x rays & rltd y,z*/
point_t xr_max_x; /* the max X found while shooting x rays & rltd y,z*/
@@ -120,120 +130,136 @@
/* Results of shooting rays down z axis */
- };
+};
- /**
- * Creates the contact pairs from the raytracing results.
- * This is the core logic of the simulation and the manifold points
- * have to satisfy certain constraints(max area within overlap region etc)
- * to have a successful simulation. The normals and penetration depth is
also
- * generated here for each point in the contact pairs. There can be upto 4
- * contact pairs.
- */
- int
- create_contact_pairs(struct sim_manifold *mf, vect_t overlap_min, vect_t
overlap_max);
+/**
+ * Creates the contact pairs from the raytracing results.
+ * This is the core logic of the simulation and the manifold points
+ * have to satisfy certain constraints(max area within overlap region etc)
+ * to have a successful simulation. The normals and penetration depth is also
+ * generated here for each point in the contact pairs. There can be upto 4
+ * contact pairs.
+ */
+int
+create_contact_pairs(struct sim_manifold *mf, vect_t overlap_min, vect_t
overlap_max);
- /**
- * Shoots rays within the AABB overlap regions only, to allow more rays to
be shot
- * in a grid of finer granularity and to increase performance. The bodies
to be targeted
- * are got from the list of manifolds returned by Bullet which carries out
AABB
- * intersection checks. These manifolds are stored in the corresponding
rigid_body
- * structures of each body participating in the simulation. The manifolds
are then used
- * to generate manifolds based on raytracing and stored in a separate list
for the body B
- * of that particular manifold. The list is freed in the next iteration in
this function
- * as well, to prevent memory leaks, before a new set manifolds are
created.
- */
- int
- generate_force(struct simulation_params *sim_params,
- struct rigid_body *rbA,
- struct rigid_body *rbB);
+/**
+ * Shoots rays within the AABB overlap regions only, to allow more rays to be
shot
+ * in a grid of finer granularity and to increase performance. The bodies to
be targeted
+ * are got from the list of manifolds returned by Bullet which carries out AABB
+ * intersection checks. These manifolds are stored in the corresponding
rigid_body
+ * structures of each body participating in the simulation. The manifolds are
then used
+ * to generate manifolds based on raytracing and stored in a separate list for
the body B
+ * of that particular manifold. The list is freed in the next iteration in
this function
+ * as well, to prevent memory leaks, before a new set manifolds are created.
+ */
+int
+generate_forces(struct simulation_params *sim_params,
+ struct rigid_body *rbA,
+ struct rigid_body *rbB);
- /**
- * Cleanup the hit list and overlap list: private to simrt
- */
- int
- cleanup_lists(void);
+/**
+ * Cleanup the hit list and overlap list: private to simrt
+ */
+int
+cleanup_lists(void);
- /**
- * Gets the exact overlap volume between 2 AABBs
- */
- int
- get_overlap(struct rigid_body *rbA, struct rigid_body *rbB, vect_t
overlap_min,
- vect_t overlap_max);
+/**
+ * Checks if the normal already exists in the list of normals
+ * encountered while raytracing
+ */
+int
+exists_normal(vect_t n);
- /**
- * Handles hits, records then in a global list
- * TODO : Stop the ray after it's left the overlap region which is being
currently
- * queried.
- */
- int
- if_hit(struct application *ap, struct partition *part_headp, struct seg
*UNUSED(segs));
+/**
+ * Gets the exact overlap volume between 2 AABBs
+ */
+int
+get_overlap(struct rigid_body *rbA, struct rigid_body *rbB, vect_t overlap_min,
+ vect_t overlap_max);
- /**
- * Handles misses while shooting manifold rays,
- * not interested in misses.
- */
- int
- if_miss(struct application *UNUSED(ap));
+/**
+ * Handles hits, records then in a global list
+ * TODO : Stop the ray after it's left the overlap region which is being
currently
+ * queried.
+ */
+int
+if_hit(struct application *ap, struct partition *part_headp, struct seg
*UNUSED(segs));
- /**
- * Handles overlaps while shooting manifold rays,
- * records the overlap regions in a global list
- *
- */
- int
- if_overlap(struct application *ap, struct partition *pp, struct region
*reg1,
- struct region *reg2, struct partition *InputHdp);
+/**
+ * Handles misses while shooting manifold rays,
+ * not interested in misses.
+ */
+int
+if_miss(struct application *UNUSED(ap));
- /**
- * Shoots a ray at the simulation geometry and fills up the hit &
- * overlap global list
- */
- int
- shoot_ray(struct rt_i *rtip, point_t pt, point_t dir);
+/**
+ * Handles overlaps while shooting manifold rays,
+ * records the overlap regions in a global list
+ *
+ */
+int
+if_overlap(struct application *ap, struct partition *pp, struct region *reg1,
+ struct region *reg2, struct partition *InputHdp);
- /**
- * Shoots a grid of rays down x axis
- */
- int
- shoot_x_rays(struct sim_manifold *current_manifold,
- struct simulation_params *sim_params,
- vect_t overlap_min,
- vect_t overlap_max);
+/**
+ * Shoots a ray at the simulation geometry and fills up the hit &
+ * overlap global list
+ */
+int
+shoot_ray(struct rt_i *rtip, point_t pt, point_t dir);
- /**
- * Traverse the hit list and overlap list, drawing the ray segments
- * for x-rays
- */
- int
- traverse_xray_lists(struct simulation_params *sim_params,
- point_t pt, point_t dir);
+/**
+ * Shoots a grid of rays down x axis
+ */
+int
+shoot_x_rays(struct sim_manifold *current_manifold,
+ struct simulation_params *sim_params,
+ vect_t overlap_min,
+ vect_t overlap_max);
- /**
- * Initializes the simulation scene for raytracing
- */
- int
- init_raytrace(struct simulation_params *sim_params);
+/**
+ * Replaces characters in a vls that are not allowed for a prim/comb name
+ * with a '$'
+ */
+void
+clear_bad_chars(struct bu_vls *vp);
- /**
- * Initializes the rayshot results structure, called before analyzing
- * each manifold through rays shot in x, y & z directions
- */
- int
- init_rayshot_results(void);
+/**
+ * Traverse the hit list and overlap list, drawing the ray segments
+ * for x-rays
+ */
+int
+traverse_xray_lists(struct simulation_params *sim_params,
+ point_t pt, point_t dir);
+
+/**
+ * Initializes the simulation scene for raytracing
+ */
+int
+init_raytrace(struct simulation_params *sim_params);
+
+
+/**
+ * Initializes the rayshot results structure, called before analyzing
+ * each manifold through rays shot in x, y & z directions
+ */
+int
+init_rayshot_results(void);
+
#if defined __cplusplus
} /* matches the linkage specification at the beginning. */
#endif
Modified: brlcad/trunk/src/libged/simulate/simulate.c
===================================================================
--- brlcad/trunk/src/libged/simulate/simulate.c 2011-10-24 20:31:57 UTC (rev
47322)
+++ brlcad/trunk/src/libged/simulate/simulate.c 2011-10-25 06:28:40 UTC (rev
47323)
@@ -324,9 +324,9 @@
insert_AABB(gedp, sim_params, current_node);
- print_manifold_list(current_node);
+ //print_manifold_list(current_node);
- insert_manifolds(gedp, sim_params, current_node);
+ //insert_manifolds(gedp, sim_params, current_node);
current_node->num_bt_manifolds = 0;
current_node->num_rt_manifolds = 0;
Modified: brlcad/trunk/src/libged/simulate/simulate.h
===================================================================
--- brlcad/trunk/src/libged/simulate/simulate.h 2011-10-24 20:31:57 UTC (rev
47322)
+++ brlcad/trunk/src/libged/simulate/simulate.h 2011-10-25 06:28:40 UTC (rev
47323)
@@ -40,7 +40,7 @@
#include "../ged_private.h"
- //Copy of the rigid body state tags from btCollisionObject.h
+ /* Copy of the rigid body state tags from btCollisionObject.h */
#define ACTIVE_TAG 1
#define ISLAND_SLEEPING 2
#define WANTS_DEACTIVATION 3
@@ -50,29 +50,30 @@
#define MAX_MANIFOLDS 4
#define MAX_CONTACTS_PER_MANIFOLD 4
- struct sim_contact {
- vect_t ptA;
- vect_t ptB;
- vect_t normalWorldOnB;
+
+struct sim_contact {
+ vect_t ptA;
+ vect_t ptB;
+ vect_t normalWorldOnB;
fastf_t depth;
- };
+};
- struct sim_manifold {
+struct sim_manifold {
struct rigid_body *rbA, *rbB;
int num_contacts;
struct sim_contact contacts[MAX_CONTACTS_PER_MANIFOLD];
- };
+};
- /* Contains information about a single rigid body constructed from a
- * BRL-CAD region. This structure is the node of a linked list
- * containing the geometry to be added to the sim.
- *
- * TODO: Only the bb is currently present, but physical properties
- * like elasticity, custom forces will be added later.
- */
- struct rigid_body {
+/* Contains information about a single rigid body constructed from a
+ * BRL-CAD region. This structure is the node of a linked list
+ * containing the geometry to be added to the sim.
+ *
+ * TODO: Only the bb is currently present, but physical properties
+ * like elasticity, custom forces will be added later.
+ */
+struct rigid_body {
int index;
char *rb_namep; /**< @brief pointer to name string */
point_t bb_min; /**< @brief body min bb bounds, only
calculated 1st time */
@@ -100,18 +101,18 @@
/* Manifold generated by RT, where this body is B, only body B has
manifold info */
int num_rt_manifolds; /**< @brief number of
manifolds for this body */
struct sim_manifold rt_manifold; /**< @brief only 1 manifold struct
needed as the manifold is used
- immediately after being generated
in the nearphase callback*/
+ immediately after being
generated in the nearphase callback*/
/* Debugging */
int iter;
- };
+};
- /* Contains the simulation parameters, such as number of rigid bodies,
- * the head node of the linked list containing the bodies and
- * time/steps for which the simulation will be run.
- */
- struct simulation_params {
+/* Contains the simulation parameters, such as number of rigid bodies,
+ * the head node of the linked list containing the bodies and
+ * time/steps for which the simulation will be run.
+ */
+struct simulation_params {
int duration; /**< @brief contains either the number
of steps or the time */
int num_bodies; /**< @brief number of rigid bodies
participating in the sim */
struct bu_vls *result_str; /**< @brief handle to the libged object
to access geometry info */
@@ -124,7 +125,7 @@
/* Debugging */
int iter;
- };
+};
#if defined __cplusplus
Modified: brlcad/trunk/src/libged/simulate/simutils.c
===================================================================
--- brlcad/trunk/src/libged/simulate/simutils.c 2011-10-24 20:31:57 UTC (rev
47322)
+++ brlcad/trunk/src/libged/simulate/simutils.c 2011-10-25 06:28:40 UTC (rev
47323)
@@ -328,6 +328,7 @@
}
bu_free_array(argc, cmd_args, "arrow: free cmd_args");
+ bu_vls_free(&arrow_line_vls);
add_to_comb(gedp, name, prefixed_arrow_line);
@@ -365,6 +366,7 @@
}
bu_free_array(argc, cmd_args, "apply_material: free cmd_args");
+ bu_vls_free(&arrow_head_vls);
add_to_comb(gedp, name, prefixed_arrow_head);
This was sent by the SourceForge.net collaborative development platform, the
world's largest Open Source development site.
------------------------------------------------------------------------------
The demand for IT networking professionals continues to grow, and the
demand for specialized networking skills is growing even more rapidly.
Take a complimentary Learning@Cisco Self-Assessment and learn
about Cisco certifications, training, and career opportunities.
http://p.sf.net/sfu/cisco-dev2dev
_______________________________________________
BRL-CAD Source Commits mailing list
brlcad-commits@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/brlcad-commits
