Particle particle_add(Particle p1, Particle p2){ // add the masses, find the center of mass Particle p3; p3.mass = p1.mass + p2.mass; double temp1[] = {0.,0.}; double temp2[] = {0.,0.}; vec_mult( p1.mass, p1.pos, temp1); vec_mult( p2.mass, p2.pos, temp2); vec_add( temp1, temp2, p3.pos ); vec_mult( 1./p3.mass, p3.pos, p3.pos ); return p3; }
t_vec *vector_proj_vector(t_vec *v1, t_vec *v2) // project vector 1 in vector 2 { t_vec *ret; ret = vec_mult(v2, dot_prod(v1, v2) / dot_prod(v2, v2)); return (ret); }
inline t_vec vector_proj_vector(const t_vec v1, const t_vec v2) { t_vec ret; ret = vec_mult(v2, dot_prod(v1, v2) / dot_prod(v2, v2)); return (ret); }
/** Hooke's law */ inline Vector spring_force(const Vector& a, const Vector& b, double length, double k) { const Vector vec = vec_sub(b, a); const double mag = vec_mag(vec); const double displacement = length - mag; return vec_mult(vec, k * displacement * 0.5 / mag); }
/** Constant tide force, does not vary with distance. */ inline Vector tide_force(const Vector& a, const Vector& b, double power) { static const double G = 0.0000000000667; const Vector vec = vec_sub(a, b); const double mag = vec_mag(vec); return vec_mult(vec, G * power / mag); }
/* diffuse shading */ static void ga_shade_diffuse(vec_t *color, const ga_material_t *mat,const vec_t *lcolor, const vec_t *ldir, const vec_t *norm, float factor){ float fact = vec_dot(*norm,*ldir); if(fact > 0.0f){ *color = vec_add(*color, vec_scale(fact*factor*mat->diff_factor ,vec_mult(mat->diff_color,*lcolor))); } }
void foo(float *p0, float *v1, float *v2, int N) { init(v1, v2, N); #pragma omp target data map(to: v1[0:N], v2[:N]) map(from: p0[0:N]) { vec_mult(p0, v1, v2, N); } output(p0, N); }
/* Computes the phong hilight */ static void ga_shade_phong(vec_t *color, const ga_material_t *mat,const vec_t *lcolor, const vec_t *ldir, const vec_t *dir, const vec_t *norm, float factor){ vec_t r; float fact; float power; r = vec_sub( vec_scale(2.0f,vec_scale(vec_dot(*norm,*ldir),*norm)), *ldir); if((fact = vec_dot(r,vec_neg(*dir))) > 0.0f){ power = powf(fact,mat->spec_power)*mat->spec_factor; *color = vec_add(*color, vec_scale( power*factor, vec_mult(mat->spec_color,*lcolor))); } }
int main () { double p1[N], p2[N]; double v1[N], v2[N]; init (v1, v2); vec_mult_ref (p1, v1, v2); vec_mult (p2, v1, v2); check (p1, p2); return 0; }
int main () { float p1[N], p2[N]; float v1[N], v2[N]; init (v1, v2); vec_mult_ref (p1, v1, v2); vec_mult (p2, v1, v2); check (p1, p2); return 0; }
int main () { float *p1 = (float *) malloc (N * sizeof (float)); float *p2 = (float *) malloc (N * sizeof (float)); vec_mult_ref (p1, N); vec_mult (p2, N); check (p1, p2, N); free (p1); free (p2); return 0; }
double get_schlick(t_pd *pd, t_inter *inter) { double ro; double cosi; double cost; ro = carre(AIR_INCI - GLASS_INCI / AIR_INCI + GLASS_INCI); cosi = dot_prod(vec_mult(pd->dir, -1), inter->norm); cost = fabs(1 - (carre(AIR_INCI / GLASS_INCI) * (1 - carre(cosi)))); if (AIR_INCI <= GLASS_INCI) return (ro + (1 - ro) * pow(1 - cosi, 5)); else if (AIR_INCI > GLASS_INCI) return (ro + (1 - ro) * pow(1 - cost, 5)); else return (1); }
int main () { int *p = (int *) malloc (MAX * sizeof (int)); int *p1 = (int *) malloc (MAX * sizeof (int)); int *v1 = (int *) malloc (MAX * sizeof (int)); int *v2 = (int *) malloc (MAX * sizeof (int)); vec_mult_ref (p, v1, v2, MAX); vec_mult (p1, v1, v2, MAX); check (p, p1, MAX); free (p); free (p1); free (v1); free (v2); return 0; }
/** Repelling charge force, ala Coulomb's law. */ inline Vector repel_force(const Region& a, const Region& b) { static const double MIN_DIST = 1.0; Vector vec; double dist = rect_distance( &vec, a.pos.x - (a.area.x / 2.0), a.pos.y - (a.area.y / 2.0), a.pos.x + (a.area.x / 2.0), a.pos.y + (a.area.y / 2.0), b.pos.x - (b.area.x / 2.0), b.pos.y - (b.area.y / 2.0), b.pos.x + (b.area.x / 2.0), b.pos.y + (b.area.y / 2.0)); if (dist <= MIN_DIST) { dist = MIN_DIST; vec = vec_sub(a.pos, b.pos); } return vec_mult(vec, (CHARGE_KE * 0.5 / (vec_mag(vec) * dist * dist))); }
int main(int argc, char *argv[]) { double t_start, t_end, t_start_OMP, t_end_OMP; DATA_TYPE* A; DATA_TYPE* B; DATA_TYPE* C; DATA_TYPE* C_OMP; A = (DATA_TYPE*)malloc(N*sizeof(DATA_TYPE)); B = (DATA_TYPE*)malloc(N*sizeof(DATA_TYPE)); C = (DATA_TYPE*)malloc(N*sizeof(DATA_TYPE)); C_OMP = (DATA_TYPE*)malloc(N*sizeof(DATA_TYPE)); fprintf(stdout, ">> Vector multiplication. Target Data Construct. <<\n"); //initialize the arrays init(A, B); t_start_OMP = rtclock(); vec_mult_OMP(A, B, C_OMP); t_end_OMP = rtclock(); fprintf(stdout, "GPU Runtime: %0.6lfs\n", t_end_OMP - t_start_OMP);//); //initialize the arrays init(A, B); t_start = rtclock(); vec_mult(A, B, C); t_end = rtclock(); fprintf(stdout, "CPU Runtime: %0.6lfs\n", t_end - t_start);//); compareResults(C, C_OMP); free(A); free(B); free(C); free(C_OMP); return 0; }
int main () { short *p1 = (short *) malloc (MAX * sizeof (short)); short *p2 = (short *) malloc (MAX * sizeof (short)); short *v1 = (short *) malloc (MAX * sizeof (short)); short *v2 = (short *) malloc (MAX * sizeof (short)); init (v1, v2, MAX); vec_mult_ref (p1, v1, v2, MAX); vec_mult (p2, v1, v2, MAX); check (p1, p2, MAX); free (p1); free (p2); free (v1); free (v2); return 0; }
/* Computes metallic reflection */ static void ga_shade_reflect(vec_t *color,const ga_scene_t *s, const ga_material_t *mat,const vec_t *pos, const vec_t *dir, const vec_t *norm, float importance, int max_rec){ vec_t r,d1,d2,dr; vec_t rcolor; int sample = mat->soft_ref_sample; int i; r = vec_sub(*dir,vec_scale(2.0f*vec_dot(*norm,*dir),*norm)); vec_fperp(&r,&d1,&d2); if(sample <= 0){ sample = 1; } i = sample; while(i--){ dr = r; vec_ffadd(&dr,mat->soft_ref_angle*(2.0f*random()*RAND_NORM) -1.0f,&d1); vec_ffadd(&dr,mat->soft_ref_angle*(2.0f*random()*RAND_NORM) -1.0f,&d2); vec_fnorm(&dr); rcolor = vec_add(rcolor, vec_scale(mat->ref_factor,vec_mult(mat->ref_color, ga_ray_trace(s,*pos,dr,importance,max_rec -1, NULL)))); } *color = vec_add(*color,vec_scale(1.0f/sample,rcolor)); }
void tracer_build(raytracer *tracer){ int ne,i,j; const int pairs[6][2]={{0,1},{0,2},{0,3},{1,2},{1,3},{2,3}}; float3 *nodes; int *elems,ebase; int e1,e0; float Rn2; if(tracer->d || tracer->m || tracer->n || tracer->mesh==NULL) return; if(tracer->mesh->node==NULL||tracer->mesh->elem==NULL|| tracer->mesh->facenb==NULL||tracer->mesh->med==NULL) MESH_ERROR("mesh is missing"); ne=tracer->mesh->ne; nodes=tracer->mesh->node; elems=(int *)(tracer->mesh->elem); // convert int4* to int* if(tracer->method==rtPlucker){ int ea,eb,ec; float3 vecAB={0.f},vecAC={0.f}; tracer->d=(float3*)calloc(sizeof(float3),ne*6); // 6 edges/elem tracer->m=(float3*)calloc(sizeof(float3),ne*6); // 6 edges/elem tracer->n=(float3*)calloc(sizeof(float3),ne*4); // 4 face norms for(i=0;i<ne;i++){ ebase=i<<2; for(j=0;j<6;j++){ e1=elems[ebase+pairs[j][1]]-1; e0=elems[ebase+pairs[j][0]]-1; vec_diff(&nodes[e0],&nodes[e1],tracer->d+i*6+j); vec_cross(&nodes[e0],&nodes[e1],tracer->m+i*6+j); } for(j=0;j<4;j++){ ea=elems[ebase+out[j][0]]-1; eb=elems[ebase+out[j][1]]-1; ec=elems[ebase+out[j][2]]-1; vec_diff(&nodes[ea],&nodes[eb],&vecAB); vec_diff(&nodes[ea],&nodes[ec],&vecAC); vec_cross(&vecAB,&vecAC,tracer->n+ebase+j); Rn2=1.f/sqrt(vec_dot(tracer->n+ebase+j,tracer->n+ebase+j)); vec_mult(tracer->n+ebase+j,Rn2,tracer->n+ebase+j); } } }else if(tracer->method==rtHavel || tracer->method==rtBadouel){ int ea,eb,ec; float3 vecAB={0.f},vecAC={0.f}; tracer->d=NULL; tracer->m=(float3*)calloc(sizeof(float3),ne*12); for(i=0;i<ne;i++){ ebase=i<<2; for(j=0;j<4;j++){ float3 *vecN=tracer->m+3*(ebase+j); ea=elems[ebase+out[j][0]]-1; eb=elems[ebase+out[j][1]]-1; ec=elems[ebase+out[j][2]]-1; vec_diff(&nodes[ea],&nodes[eb],&vecAB); vec_diff(&nodes[ea],&nodes[ec],&vecAC); vec_cross(&vecAB,&vecAC,vecN); /*N is defined as ACxAB in Jiri's code, but not the paper*/ vec_cross(&vecAC,vecN,vecN+1); vec_cross(vecN,&vecAB,vecN+2); Rn2=1.f/sqrt(vec_dot(vecN,vecN)); vec_mult(vecN,Rn2,vecN); Rn2*=Rn2; vec_mult(vecN+1,Rn2,vecN+1); vec_mult(vecN+2,Rn2,vecN+2); #ifdef MMC_USE_SSE vecN->w = vec_dot(vecN, &nodes[ea]); (vecN+1)->w=-vec_dot(vecN+1,&nodes[ea]); (vecN+2)->w=-vec_dot(vecN+2,&nodes[ea]); #endif } } }else if(tracer->method==rtBLBadouel){ int ea,eb,ec; float3 vecAB={0.f},vecAC={0.f},vN={0.f}; tracer->d=NULL; tracer->n=(float3*)calloc(sizeof(float3),ne*4); for(i=0;i<ne;i++){ ebase=i<<2; float *vecN=&(tracer->n[ebase].x); for(j=0;j<4;j++){ ea=elems[ebase+out[j][0]]-1; eb=elems[ebase+out[j][1]]-1; ec=elems[ebase+out[j][2]]-1; vec_diff(&nodes[ea],&nodes[eb],&vecAB); vec_diff(&nodes[ea],&nodes[ec],&vecAC); vec_cross(&vecAB,&vecAC,&vN); /*N is defined as ACxAB in Jiri's code, but not the paper*/ Rn2=1.f/sqrt(vec_dot(&vN,&vN)); vec_mult(&vN,Rn2,&vN); vecN[j]=vN.x; vecN[j+4]=vN.y; vecN[j+8]=vN.z; #ifdef MMC_USE_SSE vecN[j+12] = vec_dot(&vN, &nodes[ea]); #endif } } } }
color_t shootRay(ray_t ray, intersect_t *intersect, int recursionCount) { rayIntersectionTest(ray, intersect); if (intersect->t > 0) { // We hit something color_t color; GeomType geomType = intersect->geomType; void *geomObject = intersect->object; bool reflective = false; // Check the material if (geomType == GeomTypeTriangle) { triangle_t *temp = (triangle_t *)geomObject; color = temp->material.color; reflective = temp->material.reflective; } else if (geomType == GeomTypeSphere) { sphere_t *temp = (sphere_t *)geomObject; color = temp->material.color; reflective = temp->material.reflective; } else if (geomType == GeomTypeLight) { return rgb(255, 255, 255); } // Get a normal where we intersected vec_t normal; if (geomType == GeomTypeTriangle) { triangle_t *temp = (triangle_t *)geomObject; normal = temp->normal; } else if (geomType == GeomTypeSphere) { sphere_t *temp = (sphere_t *)geomObject; normal = sphere_normal_at_point(*temp, intersect->point); } if (reflective && recursionCount < 10) { // First find the reflected ray vec_t r = vec_sub(ray.direction, vec_mult(normal, 2 * vec_dot(normal, ray.direction))); point_t start = point_offset(intersect->point, vec_mult(r, 0.0001)); ray_t reflectedRay = ray_new(start, r); // Shoot out a new ray and take its color color = shootRay(reflectedRay, intersect, recursionCount + 1); } else if (!reflective) { point_t sPos = intersect->point; ray_t sRay; float totalDiffuse = 0; for (int m = 0; m < numLights; m++) { if (lights[m].size == 0) { sRay = ray_to_light(lights[m], sPos); sRay.point = point_offset(sRay.point, vec_mult(sRay.direction, 0.0001)); rayIntersectionNonLightTest(sRay, intersect); if (intersect->t <= 0) { // We did't hit anything, diffuse like normal totalDiffuse += fabsf(vec_dot(sRay.direction, normal)); } // Otherwise, we're in shadow } else { float lightRays = 100 * lights[m].size; float lightDiffuse = 0; for (int l = 0; l < lightRays; l++) { sRay = ray_to_light(lights[m], sPos); sRay.point = point_offset(sRay.point, vec_mult(sRay.direction, 0.0001)); rayIntersectionNonLightTest(sRay, intersect); if (intersect->t <= 0) { // We didn't hit anything, diffuse like normal lightDiffuse += fabsf(vec_dot(sRay.direction, normal)); } // Otherwise, we're in shadow } totalDiffuse += lightDiffuse / lightRays; } } totalDiffuse /= numLights; // We want the total intensity of lights to be the // same no matter how many we have if (totalDiffuse < 0.2) totalDiffuse = 0.2; if (totalDiffuse > 1) totalDiffuse = 1; color.r *= totalDiffuse; color.g *= totalDiffuse; color.b *= totalDiffuse; } return color; } // No intersection, color black return rgb(0, 0, 0); }
/* flat shading (doesn't depend on normal) */ static void ga_shade_flat(vec_t *color, const ga_material_t *mat, const vec_t *lcolor,float factor){ *color = vec_add(*color,vec_scale(mat->flat_factor*factor,vec_mult(mat->flat_color,*lcolor))); }