miBoolean contour_shader_widthfromlight(
miContour_endpoint *result,
miStdInfo *info_near,
miStdInfo *info_far,
miState *state,
Light_Parameters *paras)
{
miVector orgp; /* light source origin */
miVector dirp; /* light source direction */
miVector dir;
double d;
miScalar min_width;
miScalar max_width;
/* Contour color given by a parameter */
result->color = *mi_eval_color(¶s->color);
/* Get light origin or direction */
mi_light_info(*mi_eval_tag(¶s->light), &orgp, &dirp, 0);
/* Now orgp or dirp is different from the null vector */
/* Compute direction from light to point */
if (mi_vector_dot(&orgp, &orgp) > miEPS) { /* point light source */
mi_vector_sub(&dir, &info_near->point, &orgp);
} else { /* directional light source */
miASSERT(mi_vector_dot(&dirp, &dirp) > miEPS);
dir = dirp;
}
mi_vector_normalize(&dir);
/* The contour gets wider the more the normal is pointing in the same
direction as the light source */
d = mi_vector_dot(&dir, &info_near->normal);
min_width = *mi_eval_scalar(¶s->min_width);
max_width = *mi_eval_scalar(¶s->max_width);
result->width = min_width + 0.5 * (max_width - min_width) * (d+1.0);
miASSERT(min_width <= result->width && result->width <= max_width);
return(miTRUE);
}
miScalar dist_manhattan3(miVector *v1, miVector *v2) {
// 3D:
miVector s; mi_vector_sub(&s,v1,v2);
return fabs(s.x) + fabs(s.y) + fabs(s.z);
}
miScalar dist_linear_squared3(miVector *v1, miVector *v2) {
miVector s; mi_vector_sub(&s,v1,v2);
return mi_vector_dot(&s,&s);
}
miBoolean contour_shader_combi(
miContour_endpoint *result,
miStdInfo *info_near,
miStdInfo *info_far,
miState *state,
Combi_Parameters *paras)
{
miScalar depth = info_near->point.z;
double near_z, far_z, w_near, w_far;
miVector orgp; /* light source origin */
miVector dirp; /* light source direction */
miVector dir;
double d;
double factor;
miTag light;
/* Ensure that near_z and far_z are negative as they should be */
near_z = -fabs(*mi_eval_scalar(¶s->near_z));
far_z = -fabs(*mi_eval_scalar(¶s->far_z));
if (depth > near_z) { /* contour is closer than near_z */
result->color = *mi_eval_color(¶s->near_color);
result->width = *mi_eval_scalar(¶s->near_width);
} else if (depth < far_z) { /* contour is more distant than far_z*/
result->color = *mi_eval_color(¶s->far_color);
result->width = *mi_eval_scalar(¶s->far_width);
} else { /* contour is betwn near_z and far_z */
miColor near_color = *mi_eval_color(¶s->near_color);
miColor far_color = *mi_eval_color(¶s->far_color);
/* Weights w_near and w_far depend on depth */
w_near = (depth - far_z) / (near_z - far_z);
miASSERT(0.0 <= w_near && w_near <= 1.0);
w_far = 1.0 - w_near;
/* Mix of near_color and far_color according to weights */
result->color.r = w_near * near_color.r + w_far * far_color.r;
result->color.g = w_near * near_color.g + w_far * far_color.g;
result->color.b = w_near * near_color.b + w_far * far_color.b;
result->color.a = w_near * near_color.a + w_far * far_color.a;
/* Width depending on weights */
result->width = w_near * *mi_eval_scalar(¶s->near_width)
+ w_far * *mi_eval_scalar(¶s->far_width);
}
/* Width decreases by factor for each refraction_level */
factor = *mi_eval_scalar(¶s->factor);
if (factor > miEPS)
result->width *= pow(factor, (double)info_near->level - 1.0);
light = *mi_eval_tag(¶s->light);
if (light) {
miScalar light_min_factor =
*mi_eval_scalar(¶s->light_min_factor);
/* Get light origin or direction */
mi_light_info(light, &orgp, &dirp, 0);
/* Now orgp or dirp is different from the null vector */
/* Compute direction from light to point */
if (mi_vector_dot(&orgp, &orgp) > miEPS) /* point light */
mi_vector_sub(&dir, &info_near->point, &orgp);
else { /* directional light source */
miASSERT(mi_vector_dot(&dirp, &dirp) > miEPS);
dir = dirp;
}
mi_vector_normalize(&dir);
/* The contour gets wider the more the normal is pointing in
the same direction as the light source */
d = mi_vector_dot(&dir, &info_near->normal);
result->width *= 0.5 * (d + 1.0) * (1.0 - light_min_factor) +
light_min_factor;
}
miASSERT(result->width <= *mi_eval_scalar(¶s->near_width));
return(miTRUE);
}
miBoolean Facade_tex_coord(miState *state, miScalar size,
miBoolean cylindrical,
miVector *tex_point)
{
miVector facing, facade_center, observer_center;
miVector intersection;
miVector fx, fy, fz;
/* first - determine the center of the facade,
the center of the observer,
and the direction of the facade */
{
mi_point_from_object(state, &facade_center, &zero);
observer_center = state->org;
mi_vector_sub(&facing, &observer_center, &facade_center);
if (cylindrical)
{
miVector fix;
mi_vector_to_object(state, &fix, &facing);
fix.y = 0;
mi_vector_from_object(state, &facing, &fix);
}
mi_vector_normalize(&facing);
}
/* second - compute the intersection of the ray and the facade */
{
miScalar l;
l = lume_plane_ray_intersection(&intersection,
&facade_center, &facing,
&state->point, &state->dir);
if (l <= 0) /* no intersection */
return miFALSE;
}
/* third - build a coordinate system for the texture */
{
miVector object_up;
fz = facing;
mi_vector_from_object(state, &object_up, &up);
mi_vector_prod(&fx, &object_up, &fz);
mi_vector_normalize(&fx);
mi_vector_prod(&fy, &fz, &fx);
mi_vector_normalize(&fy);
}
/* forth - convert the intersection to the texture coordinate system */
{
mi_vector_sub(&intersection, &intersection, &facade_center);
tex_point->x = mi_vector_dot(&intersection, &fx);
tex_point->y = mi_vector_dot(&intersection, &fy);
tex_point->z = mi_vector_dot(&intersection, &fz);
mi_vector_div(tex_point, size);
tex_point->x += 0.5;
tex_point->y += 0.5;
}
return miTRUE;
}
miTag createMeshParticles(miState *state, mrParticleGeoShader_paras *paras, PartioContainer& pc)
{
mi_info("Creating mesh particles for cache file: %s", pc.cacheFileName.c_str());
if( ! pc.good())
{
mi_error("Invalid PartioContainer.");
return miNULLTAG;
}
Partio::ParticleAttribute posAttr;
if(!pc.assertAttribute("position", posAttr))
return miNULLTAG;
Partio::ParticleAttribute idAttr;
bool hasId = true;
if(!pc.assertAttribute("id", idAttr))
hasId = false;
Partio::ParticleAttribute radiusPPAttr;
bool hasRadiusPP = true;
if(!pc.assertAttribute("radiusPP", radiusPPAttr))
hasRadiusPP = false;
Partio::ParticleAttribute velocityAttr;
bool hasVelocity = true;
if(!pc.assertAttribute("velocity", velocityAttr))
hasVelocity = false;
miObject *obj = beginObject();
float *fpos;
srand(123345);
int numParticles = pc.data->numParticles();
float sizeMultiplier = *mi_eval_scalar(¶s->sizeMultiplier);
float density = *mi_eval_scalar(¶s->density);
float size = *mi_eval_scalar(¶s->size);
float sizeVariation = *mi_eval_scalar(¶s->sizeVariation);
// particle number can vary because of density value
int numWrittenParticles = 0;
// define vectors
for(int vtxId = 0; vtxId < numParticles; vtxId++)
{
miVector pos;
fpos = (float *)pc.data->data<float>(posAttr, vtxId);
int id = vtxId;
if( hasId)
id = *pc.data->data<int>(idAttr, vtxId);
float radiusPP = 1.0f;
if( hasRadiusPP )
radiusPP = *pc.data->data<float>(radiusPPAttr, vtxId);
miVector vel = {0.0, 0.0, 0.0};
if(hasVelocity)
{
float *v;
v = (float *)pc.data->data<float>(velocityAttr, vtxId);
vel.x = v[0];
vel.y = v[1];
vel.z = v[2];
// velocity ist distance/sekunde, eine velocity von 24 legt also eine Distanz von 1 Einheit pro frame bei 24fps zurück
// zusätzlich muss man noch den shutter angle beachten, bei 140° sind das -.2 -> 0.2 also 0.4 * 1 und damit grob .4 Einheiten
float factor = 1.0f/24.0f * 0.4f;
mi_vector_mul(&vel, factor);
}
pos.x = fpos[0];
pos.y = fpos[1];
pos.z = fpos[2];
miVector camPos = pos;
// ich transformiere das particle in camera space und gehe dann einfach size/2 nach rechts und oben
miMatrix matrix;
mi_matrix_ident(matrix);
miInstance *inst = (miInstance *)mi_db_access(state->instance);
mi_matrix_copy(matrix, inst->tf.global_to_local);
mi_db_unpin(state->instance);
mi_point_from_world(state, &camPos, &pos);
mi_point_from_world(state, &camPos, &camPos);
mi_point_to_camera(state, &camPos, &camPos);
float psize = radiusPP * sizeMultiplier;
int pId = vtxId;
double rndVal = rnd(id * state->camera->frame + 5);
if( rndVal > density)
continue;
float srndVal = (rndVal - 0.5f) * 2.0f;
psize *= size + (size * srndVal * sizeVariation * 0.5f);
psize = fabs(psize);
if(psize == 0.0f)
continue;
miVector upRight, bottomLeft;
upRight = camPos;
upRight.x += psize/2.0f;
upRight.y += psize/2.0f;
bottomLeft = camPos;
bottomLeft.x -= psize/2.0f;
bottomLeft.y -= psize/2.0f;
// checkScreenSpace in Screenspace und testet auf minPixelSize.
if(!checkScreenSpace(state, paras, camPos, bottomLeft, upRight) )
continue;
numWrittenParticles++;
miVector v0, v1, v2, v3;
v0 = bottomLeft;
v2 = upRight;
v1 = bottomLeft;
v1.y = upRight.y;
v3 = upRight;
v3.y = bottomLeft.y;
mi_point_from_camera(state, &v0, &v0);
mi_point_from_camera(state, &v1, &v1);
mi_point_from_camera(state, &v2, &v2);
mi_point_from_camera(state, &v3, &v3);
mi_point_to_world(state, &v0, &v0);
mi_point_to_world(state, &v1, &v1);
mi_point_to_world(state, &v2, &v2);
mi_point_to_world(state, &v3, &v3);
miVector v01, v02, v03;
mi_vector_sub(&v01, &v0, &v1);
mi_vector_sub(&v02, &v0, &v2);
mi_vector_sub(&v03, &v0, &v3);
mi_vector_transform(&v01, &v01, matrix);
mi_vector_transform(&v02, &v02, matrix);
mi_vector_transform(&v03, &v03, matrix);
mi_vector_add(&v1, &v0, &v01);
mi_vector_add(&v2, &v0, &v02);
mi_vector_add(&v3, &v0, &v03);
// add geometry vectors
// e.g. -0.5 -0.5 0.5
add_vector(v0.x, v0.y, v0.z);
add_vector(v1.x, v1.y, v1.z);
add_vector(v2.x, v2.y, v2.z);
add_vector(v3.x, v3.y, v3.z);
// single motion vector per particle
add_vector(vel.x, vel.y, vel.z);
}
// uv coordinates
miVector uvw;
uvw.x = uvw.y = uvw.z = 0.0f;
uvw.z = 123.0f;
mi_api_vector_xyz_add( &uvw );
uvw.x = 1.0;
mi_api_vector_xyz_add( &uvw );
uvw.y = 1.0;
mi_api_vector_xyz_add( &uvw );
uvw.x = 0.0;
mi_api_vector_xyz_add( &uvw );
// define vertices
// depending on the attributes we have x vectors per vertex:
// 0: pos1
// 1: pos2
// 2: pos3
// 3: pos4
// 4: vel
// tex0 = numWrittenParticles * 5 - 4
// num done particles für rnd density
int texIndex = numWrittenParticles * 5;
for(int vtxId = 0; vtxId < numWrittenParticles; vtxId++)
{
int vertexIndex = vtxId * 5;
int mvIndex = vtxId * 5 + 4;
// add vertex definitions
// e.g. v 0 n 8 t 32 m 46
mi_api_vertex_add(vertexIndex);
mi_api_vertex_tex_add( texIndex, -1, -1);
mi_api_vertex_motion_add(mvIndex);
mi_api_vertex_add(vertexIndex + 1);
mi_api_vertex_tex_add( texIndex + 1, -1, -1);
mi_api_vertex_motion_add(mvIndex);
mi_api_vertex_add(vertexIndex + 2);
mi_api_vertex_tex_add( texIndex + 2, -1, -1);
mi_api_vertex_motion_add(mvIndex);
mi_api_vertex_add(vertexIndex + 3);
mi_api_vertex_tex_add( texIndex + 3, -1, -1);
mi_api_vertex_motion_add(mvIndex);
}
// add poly for every particle
for( int pId = 0; pId < numWrittenParticles; pId++)
{
int vtxId = pId * 4;
mi_api_poly_begin_tag(1, miNULLTAG);
mi_api_poly_index_add(vtxId);
mi_api_poly_index_add(vtxId + 1);
mi_api_poly_index_add(vtxId + 2);
mi_api_poly_index_add(vtxId + 3);
mi_api_poly_end();
}
miTag objTag = finishObject();
return objTag;
}
