自学教程：C++ vec_scale函数代码示例

mat_t *mat_scale(float s, mat_t *a){	a->x = vec_scale(s,a->x);	a->y = vec_scale(s,a->y);	a->z = vec_scale(s,a->z);	a->w = vec_scale(s,a->w);	return a;}

void auto_orient (void){  int face;    for (face = 0; face < 6; face++)    {      float u[3], a_minus_b[3], a_minus_c[3];            vec_sub (a_minus_b, points[tristrips[face][0]],	       points[tristrips[face][1]]);      vec_scale (a_minus_b, a_minus_b, texcoords[0][1] - texcoords[2][1]);      vec_sub (a_minus_c, points[tristrips[face][0]],	       points[tristrips[face][2]]);      vec_scale (a_minus_c, a_minus_c, texcoords[0][1] - texcoords[1][1]);      vec_sub (u, a_minus_b, a_minus_c);      /* Not really sure if this is right.  */      if (((texcoords[0][0] - texcoords[1][0])	    * (texcoords[0][1] - texcoords[2][1])	   - (texcoords[0][0] - texcoords[2][0])	      * (texcoords[0][1] - texcoords[1][1])) < 0.0f)	vec_scale (u, u, -1.0f);      vec_normalize (u, u);      printf ("face %d: calculated [ %f %f %f ]/n", face, u[0], u[1], u[2]);      printf ("  previously [ %f %f %f ]/n", face_orient[face][0],	      face_orient[face][1], face_orient[face][2]);    }}

void SMat<CoeffRing>::column2by2(size_t c1,                                 size_t c2,                                 elem a1,                                 elem a2,                                 elem b1,                                 elem b2)/* column(c1) <- a1 * column(c1) + a2 * column(c2),   column(c2) <- b1 * column(c1) + b2 * column(c2)*/{  // Make first column: v1 = a1*c1+a2*c2  sparsevec *v1 = vec_copy(columns_[c1]);  sparsevec *v2 = vec_copy(columns_[c2]);  vec_scale(v1, a1);  vec_scale(v2, a2);  vec_add_to(v1, v2);  // Second column: w1 = b1*c1 + b2*c2  sparsevec *w1 = columns_[c1];  sparsevec *w2 = columns_[c2];  vec_scale(w1, b1);  vec_scale(w2, b2);  vec_add_to(w1, w2);  // Set the matrices:  columns_[c1] = v1;  columns_[c2] = w1;}

/* Computes ambiant occlusion */static void ga_shade_ao(vec_t *color, const ga_scene_t *s, const ga_material_t *mat, const vec_t *pos, const vec_t *norm, float importance){	int sample = mat->ao_sample;	float rlen,fact;	vec_t ao_color = vec_new(0,0,0,1);	vec_t dsample,d1,d2;	vec_fperp(norm,&d1,&d2);	while(sample--){		dsample = vec_new(0,0,0,1);		vec_ffadd(&dsample,random()*RAND_NORM,norm);		vec_ffadd(&dsample,(2.0f*random()*RAND_NORM) -1.0f,&d1);		vec_ffadd(&dsample,(2.0f*random()*RAND_NORM) -1.0f,&d2);		vec_fnorm(&dsample);		rlen = ga_ray_length(s,*pos,dsample);		if (rlen <= mat->ao_min_dist){			ao_color = vec_add(ao_color,mat->ao_min_color);		}else if (rlen >= mat->ao_max_dist){			ao_color = vec_add(ao_color,mat->ao_max_color);		}else{			fact = (rlen - mat->ao_min_dist) / (mat->ao_max_dist - mat->ao_min_dist) ;			ao_color = vec_add(ao_color,					vec_add(vec_scale(fact,mat->ao_max_color),						vec_scale(1.0f-fact,mat->ao_min_color)));		}	}	*color = vec_add(*color,			vec_scale(1.0f/mat->ao_sample*mat->ao_factor,ao_color));}

BOOL crLottiUpdateFly (ENTITY* e){	VECTOR v, w;		vec_set(&w, e->crAccel);	vec_scale(&w, time_step);	vec_add(e->crSpeed, &w);		vec_set(&v, e->crSpeed);	vec_scale(&v, time_step);	vec_add(e->x, &v);		VECTOR feet;		feet.x = feet.y = 0;	feet.z = 0.5 * e->min_z;		vec_rotate(feet, e->pan);	vec_add(feet, e->x);		ent_animate(e, "drown", 5 * total_ticks + e->crInit, ANM_CYCLE);		effect(credits_fire, 2, feet, e->crSpeed);		// explode near screen border	VECTOR v;	vec_set(&v, e->x);		vec_to_screen(&v, camera);		return (v.x < e->crPercent * screen_size.x || v.x > (1 - e->crPercent) * screen_size.x ||	        v.y < e->crPercent * screen_size.y || v.y > (1 - e->crPercent) * screen_size.y);}

void compute_ray(RAY* ray, VECTOR3D* view_point, VIEWPORT* viewport, PIXEL* pixel, VEC_BASIS* camera_frame, double distance) {	float u, v;	VECTOR3D v1, v2, v3, v4, dir;			// 1. calculate u and v coordinates of the pixels on the image plane:	u = (double)(viewport->xvmin) + (double)(pixel->i) + 0.5 ;  	v = (double)(viewport->yvmin) + (double)(pixel->j) + 0.5 ;  		// 2. calculate ray direction		vec_scale(-distance, &v1, &camera_frame->n);	vec_scale(u, &v2, &camera_frame->u);	vec_scale(v, &v3, &camera_frame->v);		ray->origin.x = view_point->x;  	ray->origin.y = view_point->y;	ray->origin.z = view_point->z;		vec_add(&v4, &v1, &v2);	vec_add(&dir, &v4, &v3);	normalize_vector(&dir);		ray->direction.x = dir.x;	ray->direction.y = dir.y;	ray->direction.z = dir.z;}

void integrate(particle_t *src, particle_t *dst, vec3f acceleration, float dt){    // euler-cromer method    // v' = v + a*dt    --    v, v' and a are vectors, dt is a scalar.    dst->velocity = vec_add(src->velocity, vec_scale(acceleration, dt));    // x' = x + v'*dt   --    x', x, v' are vectors, dt is a scalar.    dst->position = vec_add(src->position, vec_scale(dst->velocity, dt));}

Vector getReflectedRay(Vector surface_norm, Vector light_ray){	float cosTheta1 = vec_dot(surface_norm, vec_scale(light_ray,-1));	Vector reflect_ray = vec_plus(light_ray, vec_scale(surface_norm, 2*cosTheta1));	return reflect_ray;}

// Calculate normal vector in the point of intersection:void intersection_normal(SPHERE *sphere, SPHERE_INTERSECTION* intersection, RAY* ray) {		double lambda, scale;	VECTOR3D v1, v2, point, normal;		lambda = intersection->lambda_in;		vec_scale(lambda, &v1, &ray->direction);	vec_add(&point, &v1, &ray->origin);		intersection->point.x = point.x;	intersection->point.y = point.y;	intersection->point.z = point.z;		vec_sub(&v2, &point, &sphere->center);		scale = 1.0 / sphere->radius;	vec_scale(scale, &normal, &v2);		normalize_vector(&normal);	intersection->normal.x = normal.x;	intersection->normal.y = normal.y;	intersection->normal.z = normal.z;	}

box_t box_bounds(box_t b) {  vec_t corner = vec_add(vec_abs(vec_scale(b.axis0, b.size.x)), vec_abs(vec_scale(b.axis1, b.size.y)));  box_t r;  r.pos = b.pos;  r.size = corner;  r.axis0 = vec_new(corner.x, 0);  r.axis1 = vec_new(0, corner.y);  return r;}

//reflect a vector from a surface plane]void vec_reflect(vec_t *n, vec_t *w, vec_t *v) {    vec_t *u = (vec_t *)malloc(sizeof(vec_t));    vec_unit(w, u);    vec_scale(-1, u, u);    vec_scale((2*vec_dot(u, n)), n, v);    vec_diff(u, v, v);    free(u);}

/* 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)));	}}

rgb lighting(scene s, ray r, hit_test h){  rgb result;  if (h.miss)    return s.bg;  vec hit_position = ray_position(r, h.dist);  if (shadow(hit_position, s.light, s.spheres)) {    result = rgb_modulate(h.surf, s.amb);  }  else {      double dot = vec_dot(h.surf_norm, s.light.direction);    double d = double_max(0, dot);    rgb diffuse_light = rgb_scale(d, s.light.color);    rgb lsum = rgb_add(s.amb, diffuse_light);    result = rgb_modulate(h.surf, lsum);  }  /**** === implement specular reflection here === ****/   if (rgb_nonzero(h.shine)) {    rgb ss;    vec N = h.surf_norm;    vec L = s.light.direction;    rgb S = h.shine;    vec R = vec_sub( vec_scale(2* vec_dot(N,L),N),L);    vec V = vec_neg(r.direction);    if (vec_dot(N,L)>0){      ss = rgb_scale( pow( double_max( vec_dot(R,V),0), 6), S);      //rgb_print(k);    }    else      ss = rgb_expr(0,0,0);    return rgb_add(result,ss);  }  return result;}

void item_fade(){	var vTicks = total_ticks;	VECTOR vecDist;		var fadeScale = my->scale_x;	vec_set(&vecDist, &my->x);	vec_sub(&vecDist, &player->x);	while (my->scale_x > 0)	{		wait(1);		//scale down item		my->scale_x -= 0.1 * time_step * fadeScale;		my->scale_y = my->scale_x;		my->scale_z = my->scale_x;		my->pan += (total_ticks - vTicks) * 10 * time_step;		//move item towards player		vec_set(&my->x, &vecDist);		vec_scale(&my->x, my->scale_x / fadeScale);		vec_add(&my->x, &player->x);	}	itemCounter--;	ptr_remove(me);}

double plane_t::hits(vec_t *base, vec_t* dir){	double ndotd;	double t;	double ndotb;	ndotq = vec_dot(&normal, &point);	ndotd = vec_dot(dir, &normal);	/* ndotd = 0 -> ray is parallel to the plane */	if (ndotd == 0)		return(-1);	ndotb = vec_dot(&normal, base);	t = (ndotq - ndotb) / ndotd;	if (t <= 0)		return(-1);	vec_scale(t, dir, &last_hitpt);	vec_sum(&last_hitpt, base, &last_hitpt);	if ((last_hitpt.z > 0.01) && (strcmp(obj_type, "projector")))		return(-1);	return(t);}

voidlightsource_fake_phong (float *vertex, float *norm, const float *light_pos,			const float *light_up, const float *eye_pos,			matrix_t *invcamera, vertex_attrs *vertex_info,			unsigned int idx){  float norm_light[3];  float eye_to_vertex[3], tmp[3], reflection[3];  float light_to_vertex[3];  float eye_dot_norm;    vec_sub (light_to_vertex, light_pos, vertex);  vec_normalize (norm_light, light_to_vertex);    vec_sub (eye_to_vertex, eye_pos, vertex);  vec_normalize (eye_to_vertex, eye_to_vertex);    eye_dot_norm = vec_dot (eye_to_vertex, norm);  vec_scale (tmp, norm, 2.0 * eye_dot_norm);  vec_sub (reflection, tmp, eye_to_vertex);  if (eye_dot_norm < 0)    vertex_info[idx].fakephong.transformed_z = -0.01;  else    fakephong_texcoords (&vertex_info[idx].fakephong.texc[0],			 &vertex_info[idx].fakephong.texc[1],			 reflection, norm_light, light_up,			 &vertex_info[idx].fakephong.transformed_z);}

vec *ray_position(ray *r, double t){    vec *w = vec_scale(t, r->direction);    vec *result = vec_add(r->origin, w);    vec_free(w);    return result;}

double plane_t::hits(vec_t    *base,      /* ray base              */vec_t    *dir)       /* unit direction vector */{   double   ndotd;   double   t;   double   ndotb;   ndotq = vec_dot(&normal, &point);   ndotd = vec_dot(dir, &normal);/* ndotd = 0 -> ray is parallel to the plane */   if (ndotd == 0)       return(-1);   ndotb = vec_dot(&normal, base);   t = (ndotq - ndotb) / ndotd;   if (t <= 0)      return(-1);   vec_scale(t, dir, &hitloc);   vec_sum(&hitloc, base, &hitloc);   if (hitloc.z > 0.001)      return(-1);   return(t);}

/* Construct a unit vector v2 in direction of input vector v1 */void vec_unit(    vec_t *v1,    /* Input vector      */    vec_t *v2)    /* output unit vec   */{    double mult = 1 / vec_len(v1);    vec_scale(mult, v1, v2);}

void SMat<CoeffRing>::vec_column_op(sparsevec *&v, const elem &a, sparsevec *w) const    // v := v + a*w{  sparsevec *w1 = vec_copy(w);  vec_scale(w1, a);  vec_add_to(v, w1);}

vec_t vec_normalize(vec_t a){	if (vec_zero(a)){		return a;	}else{		return vec_scale(a,1.0/vec_len(a));	}}

//Brief: QR decomposition void qrdec(mat *A, mat* R){    double proj = 0;    double norm = 0;        // Allocates pointers of type *vec     //vec *coli = (vec*)malloc(sizeof(vec));    //vec *colj = (vec*)malloc(sizeof(vec));    vec* coli = vec_new(A->row);    vec* colj = vec_new(A->row);    for(int i=0; i<A->col; i++){	mat_get_col(coli, A, i);		norm = vec_norm(coli);	mat_set(R, i, i, norm);	vec_scale(coli, 1.0/norm);	mat_set_col(A, coli, i);	for(int j=i+1; j<A->col; j++){	    mat_get_col(colj, A, j);	    proj = vec_dot(coli,colj);	    vec_add(colj,coli,-proj);	    mat_set_col(A, colj, j);	    mat_set(R, i, j, proj);	}	    }    // Free pointers    vec_free(coli);    vec_free(colj);}

/* Function compute_means. * This function recomputes the means based on the current clustering * of the points. * * Inputs: *   n          : number of input descriptors *   dim        : dimension of each input descriptor *   k          : number of means *   v          : array of pointers to dim-dimensional descriptors *   clustering : current assignment of descriptors to means (should *                range between 0 and k-1) * * Output: *   means_out  : array of output means.  You need to fill this *                array.  The means should be concatenated into one *                long array of length k*dim. */double compute_means(int n, int dim, int k, unsigned char **v,                     unsigned int *clustering, double *means_out){    int i;    double max_change = 0.0;    int *counts = (int *) malloc(sizeof(int) * k);    for (i = 0; i < k * dim; i++)        means_out[i] = 0.0;    for (i = 0; i < k; i++)        counts[i] = 0;    for (i = 0; i < n; i++) {        unsigned int cluster = clustering[i];        vec_accum(dim, means_out + cluster * dim, v[i]);        counts[cluster]++;    }    /* Normalize new means */    for (i = 0; i < k; i++) {        if (counts[i] == 0) {            continue;        }        vec_scale(dim, means_out + i * dim, 1.0 / counts[i]);    }    free(counts);    return max_change;}

vec_t vec_norm(vec_t a){	float len = vec_len(a);	if(len == 0.0f){		return vec_new(1.0f,0.0f,0.0f,0.0f);	}else{		return vec_scale(1.0f/len,a);	}}

/* 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)));	}}

//project a vector onto a planevoid vec_project(vec_t *n, vec_t *v, vec_t *p) {    vec_t *r = (vec_t *)malloc(sizeof(vec_t));    vec_scale(vec_dot(n, v), n, r);    vec_diff(r, v, p);    free(r);}

Vector getRefractedRay(float initial_refraction, Spheres *sph, Vector surface_norm, Vector light_ray){	float refraction_index = sph->refraction_index;	float n = initial_refraction/refraction_index;	Vector refract_ray;	//n = .9;	//light_ray.x = 0.707107;	//light_ray.y = -0.707107;	//light_ray.z = 0;	//surface_norm.x = 0;	//surface_norm.y = 1;	//surface_norm.z = 0;	float cosTheta1 = vec_dot(surface_norm, vec_scale(light_ray,-1));	float cosTheta2 = sqrt(1.0f-pow(n,2)*(1-(cosTheta1*cosTheta1)));		Vector a = vec_scale(light_ray, n);	Vector b = vec_scale(surface_norm, n*cosTheta1 - cosTheta2);	if(cosTheta1 > 0.0f)	{		refract_ray = vec_plus(vec_scale(light_ray,n), vec_scale(surface_norm, n*cosTheta1-cosTheta2));	}	else	{		refract_ray = vec_minus(vec_scale(light_ray,n), vec_scale(surface_norm, n*cosTheta1-cosTheta2));	}	return refract_ray;}

static gameComponentT* createPhysicsComponent(void) {    gameComponentT* component = newPhysicsComponent(1.0f * Kilogram);        physicsComponentDataT* phys = component->data;        vec2 pos;    vec2 vel;        switch (rand() % 4) {            case 0: {        // Spawn above screen.        pos = (vec2) { -0.5f + 1.0f * rand()/(float)RAND_MAX, 0.6f };        vel = (vec2) { -1.0f + 2.0f * rand()/(float)RAND_MAX,                       -0.2f - 1.0f * rand()/(float)RAND_MAX };        break;    };    case 1: {        // Spawn to the right of screen.        pos = (vec2) {  1.0f, -0.5f + 1.0f * rand()/(float)RAND_MAX };        vel = (vec2) { -0.2f - 1.0f * rand() / (float)RAND_MAX,                       -1.0f + 2.0f * rand() / (float)RAND_MAX };        break;    };    case 2: {        // Spawn below screen.        pos = (vec2) { -0.5f + 1.0f * rand()/(float)RAND_MAX, -0.6f };        vel = (vec2) { -1.0f + 2.0f * rand()/(float)RAND_MAX,                        0.2f + 1.0f * rand()/(float)RAND_MAX };        break;    };    case 3: {        // Spawn to the left of screen.        pos = (vec2) { -1.0f, -0.5f + 1.0f * rand()/(float)RAND_MAX };        vel = (vec2) {  0.2f + 1.0f * rand() / (float)RAND_MAX,                       -1.0f + 2.0f * rand() / (float)RAND_MAX };        break;    };    }    vec_scale(&pos, 6.0f, &pos);    //bodySetOrientation(((physicsComponentDataT*)phys)->body, 17 * 3.141592f / 180.0f);    //pos.x = -1.0f;    //pos.y = 0.0f;    //vel.x = -1.0f;    //vel.y = 0.0f;    bodySetPosition(((physicsComponentDataT*)phys)->body, pos);    //vec_scale(&vel, 0.1f, &vel);    bodySetVelocity(((physicsComponentDataT*)phys)->body, vel);        return (component);}

vec_t vec_homog(vec_t a){	if(a.w == 0.0f){		return a;	}else{		a = vec_scale(1.0/a.w,a);		a.w = 1.0;		return a;	}}

vec_t vec_vec(vec_t a){	if (a.w == 0.0f){		return a;	}else{		a = vec_scale(1.0f/a.w,a);		a.w = 0.0f;		return a;	}}