[Bf-blender-cvs] [41359fe] hair_system: Merge branch 'master' into hair_system

Lukas Tönne noreply at git.blender.org
Wed Sep 24 11:02:30 CEST 2014


Commit: 41359fe31c1b2873396ab97b5efda379642cd549
Author: Lukas Tönne
Date:   Wed Sep 24 11:01:56 2014 +0200
Branches: hair_system
https://developer.blender.org/rB41359fe31c1b2873396ab97b5efda379642cd549

Merge branch 'master' into hair_system

Conflicts:
	intern/cycles/blender/addon/ui.py
	intern/cycles/blender/blender_curves.cpp

===================================================================



===================================================================

diff --cc intern/cycles/blender/blender_curves.cpp
index d4597dd,8cfaea5..c81c243
--- a/intern/cycles/blender/blender_curves.cpp
+++ b/intern/cycles/blender/blender_curves.cpp
@@@ -38,10 -39,12 +39,10 @@@ void InterpolateKeySegments(int seg, in
  bool ObtainCacheParticleUV(Mesh *mesh, BL::Mesh *b_mesh, BL::Object *b_ob, ParticleCurveData *CData, bool background, int uv_num);
  bool ObtainCacheParticleVcol(Mesh *mesh, BL::Mesh *b_mesh, BL::Object *b_ob, ParticleCurveData *CData, bool background, int vcol_num);
  bool ObtainCacheParticleData(Mesh *mesh, BL::Mesh *b_mesh, BL::Object *b_ob, ParticleCurveData *CData, bool background);
- void ExportParticleCurveTrianglePlanes(Mesh *mesh, ParticleCurveData *CData, float3 RotCam);
 -void ExportCurveSegments(Scene *scene, Mesh *mesh, ParticleCurveData *CData);
 -void ExportCurveTrianglePlanes(Mesh *mesh, ParticleCurveData *CData,
 -                               float3 RotCam, bool is_ortho);
 -void ExportCurveTriangleGeometry(Mesh *mesh, ParticleCurveData *CData, int resolution);
 -void ExportCurveTriangleUV(Mesh *mesh, ParticleCurveData *CData, int vert_offset, int resol, float3 *uvdata);
 -void ExportCurveTriangleVcol(Mesh *mesh, ParticleCurveData *CData, int vert_offset, int resol, uchar4 *cdata);
++void ExportParticleCurveTrianglePlanes(Mesh *mesh, ParticleCurveData *CData, float3 RotCam, bool is_ortho);
 +void ExportParticleCurveTriangleGeometry(Mesh *mesh, ParticleCurveData *CData, int resolution);
 +void ExportParticleCurveTriangleUV(Mesh *mesh, ParticleCurveData *CData, int vert_offset, int resol, float3 *uvdata);
 +void ExportParticleCurveTriangleVcol(Mesh *mesh, ParticleCurveData *CData, int vert_offset, int resol, uchar4 *cdata);
  
  ParticleCurveData::ParticleCurveData()
  {
@@@ -327,7 -330,8 +328,7 @@@ static void set_resolution(Mesh *mesh, 
  	}
  }
  
- void ExportParticleCurveTrianglePlanes(Mesh *mesh, ParticleCurveData *CData, float3 RotCam)
 -void ExportCurveTrianglePlanes(Mesh *mesh, ParticleCurveData *CData,
 -                               float3 RotCam, bool is_ortho)
++void ExportParticleCurveTrianglePlanes(Mesh *mesh, ParticleCurveData *CData, float3 RotCam, bool is_ortho)
  {
  	int vertexno = mesh->verts.size();
  	int vertexindex = vertexno;
@@@ -680,348 -690,7 +687,352 @@@ static void ExportParticleCurveSegments
  	}
  }
  
 -void ExportCurveTriangleUV(Mesh *mesh, ParticleCurveData *CData, int vert_offset, int resol, float3 *uvdata)
 +static void hair_step_iter_eval(BL::HairRenderStepIterator b_step_iter, float3 &co, float3 frame[3], float &param)
 +{
 +	float fco[3], fnor[3], ftan[3], fcotan[3], fhair_radius;
 +	
 +	param = b_step_iter.parameter();
 +	
 +	b_step_iter.eval(fco, &fhair_radius);
 +	co = make_float3(fco[0], fco[1], fco[2]);
 +	
 +	b_step_iter.eval_frame(fnor, ftan, fcotan);
 +	frame[0] = make_float3(fnor[0], fnor[1], fnor[2]);
 +	frame[1] = make_float3(ftan[0], ftan[1], ftan[2]);
 +	frame[2] = make_float3(fcotan[0], fcotan[1], fcotan[2]);
 +}
 +
 +/* evaluate curve at each step:
 + *   v_p, v, v_n:       previous/current/next location
 + *   d, d_n:            current/next direction
 + *   param, param_n:    current/next curve parameter
 + */
 +static void hair_curve_triangle_step(int step, BL::HairRenderStepIterator b_step_iter, float3 &v_p, float3 &v, float3 &v_n, float3 &d, float3 &d_n,
 +                                     float &param, float &param_n, float3 frame[3], float3 frame_n[3])
 +{
 +	if (step == 0) {
 +		hair_step_iter_eval(b_step_iter, v, frame, param);
 +		v_p         = v;
 +		b_step_iter.next();
 +		
 +		hair_step_iter_eval(b_step_iter, v_n, frame_n, param_n);
 +		d = d_n     = v_n - v;
 +		b_step_iter.next();
 +	}
 +	else if (step < b_step_iter.totsteps() - 1) {
 +		v_p         = v;
 +		v           = v_n;
 +		param       = param_n;
 +		d           = d_n;
 +		
 +		hair_step_iter_eval(b_step_iter, v_n, frame_n, param_n);
 +		d_n         = v_n - v;
 +		b_step_iter.next();
 +	}
 +	else {
 +		param       = param_n;
 +		v_p         = v;
 +		v           = v_n;
 +		d           = d_n;
 +	}
 +}
 +
- static void ExportHairCurveTrianglePlanes(Mesh *mesh, BL::HairSystem b_hsys, float3 RotCam)
++static void ExportHairCurveTrianglePlanes(Mesh *mesh, BL::HairSystem b_hsys, float3 RotCam, bool is_ortho)
 +{
 +	BL::HairRenderSettings b_render(b_hsys.params().render());
 +	float shape = b_render.shape();
 +	float root_width = b_render.root_width() * b_render.radius_scale();
 +	float tip_width = b_render.tip_width() * b_render.radius_scale();
 +	bool closetip = b_render.use_closetip();
 +	int shader = mesh->used_shaders[clamp(b_render.material_slot()-1, 0, mesh->used_shaders.size()-1)];
 +	
 +	int vertexno = mesh->verts.size();
 +	int vertexindex = vertexno;
 +	int numverts = 0, numtris = 0;
 +	
 +	BL::HairRenderIterator b_hair_iter = b_hsys.render_iterator();
 +	b_hair_iter.init();
 +	
 +	/* compute and reserve size of arrays */
 +	int num_curves, num_keys;
 +	b_hair_iter.count(&num_curves, &num_keys);
 +	numverts += 2 + (num_keys - 1)*2;
 +	numtris += (num_keys - 1)*2;
 +	
 +	mesh->verts.reserve(mesh->verts.size() + numverts);
 +	mesh->triangles.reserve(mesh->triangles.size() + numtris);
 +	mesh->shader.reserve(mesh->shader.size() + numtris);
 +	mesh->smooth.reserve(mesh->smooth.size() + numtris);
 +	
 +	/* actually export */
 +	for (; b_hair_iter.valid(); b_hair_iter.next()) {
 +		BL::HairRenderStepIterator b_step_iter = b_hair_iter.step_init();
 +		int totsteps = b_step_iter.totsteps();
 +		if (totsteps <= 1)
 +			continue;
 +		
 +		float3 v_p, v, v_n, d, d_n, frame[3], frame_n[3];
 +		float param, param_n;
 +		
 +		for (int step = 0; step < totsteps; ++step) {
 +			hair_curve_triangle_step(step, b_step_iter, v_p, v, v_n, d, d_n, param, param_n, frame, frame_n);
 +			
 +			float radius = shaperadius(shape, root_width, tip_width, param);
 +			if (closetip && step == totsteps - 1)
 +				radius = 0.0f;
 +			
 +			float3 ickey_loc = v;
- 			float3 xbasis = normalize(cross(RotCam - ickey_loc, d));
++			float3 xbasis;
++			if(is_ortho)
++				xbasis = normalize(cross(RotCam, d));
++			else
++				xbasis = normalize(cross(RotCam - ickey_loc, d));
 +			float3 ickey_loc_shfl = ickey_loc - radius * xbasis;
 +			float3 ickey_loc_shfr = ickey_loc + radius * xbasis;
 +			mesh->verts.push_back(ickey_loc_shfl);
 +			mesh->verts.push_back(ickey_loc_shfr);
 +			if (step > 0) {
 +				mesh->add_triangle(vertexindex-2, vertexindex, vertexindex-1, shader, true);
 +				mesh->add_triangle(vertexindex+1, vertexindex-1, vertexindex, shader, true);
 +			}
 +			vertexindex += 2;
 +		}
 +	}
 +	b_hair_iter.end();
 +
 +	mesh->reserve(mesh->verts.size(), mesh->triangles.size(), 0, 0);
 +	mesh->attributes.remove(ATTR_STD_VERTEX_NORMAL);
 +	mesh->attributes.remove(ATTR_STD_FACE_NORMAL);
 +	mesh->add_face_normals();
 +	mesh->add_vertex_normals();
 +	mesh->attributes.remove(ATTR_STD_FACE_NORMAL);
 +
 +	/* texture coords still needed */
 +}
 +
 +static void ExportHairCurveTriangleGeometry(Mesh *mesh, BL::HairSystem b_hsys, int resolution)
 +{
 +	BL::HairRenderSettings b_render(b_hsys.params().render());
 +	float shape = b_render.shape();
 +	float root_width = b_render.root_width() * b_render.radius_scale();
 +	float tip_width = b_render.tip_width() * b_render.radius_scale();
 +	bool closetip = b_render.use_closetip();
 +	int shader = mesh->used_shaders[clamp(b_render.material_slot()-1, 0, mesh->used_shaders.size()-1)];
 +	
 +	int vertexno = mesh->verts.size();
 +	int vertexindex = vertexno;
 +	int numverts = 0, numtris = 0;
 +	
 +	BL::HairRenderIterator b_hair_iter = b_hsys.render_iterator();
 +	b_hair_iter.init();
 +	
 +	/* compute and reserve size of arrays */
 +	int num_curves, num_keys;
 +	b_hair_iter.count(&num_curves, &num_keys);
 +	numverts += (num_keys - 2)*2*resolution + resolution;
 +	numtris += (num_keys - 2)*resolution;
 +	
 +	mesh->verts.reserve(mesh->verts.size() + numverts);
 +	mesh->triangles.reserve(mesh->triangles.size() + numtris);
 +	mesh->shader.reserve(mesh->shader.size() + numtris);
 +	mesh->smooth.reserve(mesh->smooth.size() + numtris);
 +	
 +	/* actually export */
 +	for (; b_hair_iter.valid(); b_hair_iter.next()) {
 +		BL::HairRenderStepIterator b_step_iter = b_hair_iter.step_init();
 +		int totsteps = b_step_iter.totsteps();
 +		if (totsteps <= 1)
 +			continue;
 +		
 +		float3 v_p, v, v_n, d, d_n, frame[3], frame_n[3];
 +		float param, param_n;
 +		
 +		for (int step = 0; step < totsteps; ++step) {
 +			hair_curve_triangle_step(step, b_step_iter, v_p, v, v_n, d, d_n, param, param_n, frame, frame_n);
 +			
 +			float radius = shaperadius(shape, root_width, tip_width, param);
 +			if (closetip && step == totsteps - 1)
 +				radius = 0.0f;
 +			
 +			float3 xbasis = frame[1];
 +			float3 ybasis = frame[2];
 +			
 +			float3 ickey_loc = v;
 +			
 +			float angle = M_2PI_F / (float)resolution;
 +			for(int section = 0; section < resolution; section++) {
 +				float3 ickey_loc_shf = ickey_loc + radius * (cosf(angle * section) * xbasis + sinf(angle * section) * ybasis);
 +				mesh->verts.push_back(ickey_loc_shf);
 +			}
 +			
 +			if(step > 0) {
 +				for(int section = 0; section < resolution - 1; section++) {
 +					mesh->add_triangle(vertexindex - resolution + section, vertexindex + section, vertexindex - resolution + section + 1, shader, true);
 +					mesh->add_triangle(vertexindex + section + 1, vertexindex - resolution + section + 1, vertexindex + section, shader, true);
 +				}
 +				mesh->add_triangle(vertexindex-1, vertexindex + resolution - 1, vertexindex - resolution, shader, true);
 +				mesh->add_triangle(vertexindex, vertexindex - resolution , vertexindex + resolution - 1, shader, true);
 +			}
 +			vertexindex += resolution;
 +		}
 +	}
 +	b_hair_iter.end();
 +
 +	mesh->reserve(mesh->verts.size(), mesh->triangles.size(), 0, 0);
 +	mesh->attributes.remove(ATTR_STD_VERTEX_NORMAL);
 +	mesh->attributes.remove(ATTR_STD_FACE_NORMAL);
 +	mesh->add_face_normals();
 +	mesh->add_vertex_normals();
 +	mesh->attributes.remove(ATTR_STD_FACE_NORMAL);
 +
 +	/* texture coords still needed */
 +}
 +
 +static void ExportHairCurveSegments(Scene *scene, Mesh *mesh, BL::HairSystem b_hsys)
 +{
 +	BL::HairRenderSettings b_render(b_hsys.params().render());
 +	float shape = b_render.sh

@@ Diff output truncated at 10240 characters. @@




More information about the Bf-blender-cvs mailing list