[Bf-blender-cvs] [f3eb33c] alembic_pointcache: Make sure mesh data is really stored and reconstructed from the cache entirely.

Lukas Tönne noreply at git.blender.org
Thu Mar 19 18:08:22 CET 2015


Commit: f3eb33c47607a59f9b25f1470b66864915dc6372
Author: Lukas Tönne
Date:   Thu Mar 19 18:07:03 2015 +0100
Branches: alembic_pointcache
https://developer.blender.org/rBf3eb33c47607a59f9b25f1470b66864915dc6372

Make sure mesh data is really stored and reconstructed from the cache
entirely.

Also the code is much better structured now, moving toward a more
standardized sample/schema class definition.

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

M	source/blender/pointcache/alembic/abc_mesh.cpp
M	source/blender/pointcache/alembic/abc_mesh.h

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

diff --git a/source/blender/pointcache/alembic/abc_mesh.cpp b/source/blender/pointcache/alembic/abc_mesh.cpp
index e8f995b..1d6afc6 100644
--- a/source/blender/pointcache/alembic/abc_mesh.cpp
+++ b/source/blender/pointcache/alembic/abc_mesh.cpp
@@ -45,6 +45,33 @@ using namespace AbcGeom;
 /* CD layers that are stored in generic customdata arrays created with CD_ALLOC */
 static CustomDataMask CD_MASK_CACHE = ~(CD_MASK_MVERT | CD_MASK_MEDGE | CD_MASK_MFACE | CD_MASK_MPOLY | CD_MASK_MLOOP | CD_MASK_BMESH | CD_MASK_MTFACE);
 
+struct MVertSample {
+	std::vector<V3f> co;
+	std::vector<N3f> no;
+	std::vector<int8_t> flag;
+	std::vector<int8_t> bweight;
+};
+
+struct MEdgeSample {
+	std::vector<uint32_t> verts;
+	std::vector<int16_t> flag;
+	std::vector<int8_t> crease;
+	std::vector<int8_t> bweight;
+};
+
+struct MPolySample {
+	/*std::vector<int32_t> loopstart;*/ /* loopstart is not stored explicitly */
+	std::vector<int32_t> totloop;
+	std::vector<int16_t> mat_nr;
+	std::vector<int8_t> flag;
+};
+
+struct MLoopSample {
+	/* XXX these are unsigned int in DNA, but Alembic expects signed int */
+	std::vector<int32_t> verts;
+	std::vector<int32_t> edges;
+};
+
 AbcDerivedMeshWriter::AbcDerivedMeshWriter(const std::string &name, Object *ob, DerivedMesh **dm_ptr) :
     DerivedMeshWriter(ob, dm_ptr, name),
     m_vert_data_writer("vertex_data", CD_MASK_CACHE),
@@ -67,17 +94,23 @@ void AbcDerivedMeshWriter::init_abc(OObject parent)
 	m_mesh = OPolyMesh(parent, m_name, abc_archive()->frame_sampling_index());
 	
 	OPolyMeshSchema &schema = m_mesh.getSchema();
-	OCompoundProperty geom_props = schema.getArbGeomParams();
+//	OCompoundProperty geom_props = schema.getArbGeomParams();
 	OCompoundProperty user_props = schema.getUserProperties();
 	
-	m_param_smooth = OBoolGeomParam(geom_props, "smooth", false, kUniformScope, 1, 0);
+	m_prop_vert_normals = ON3fArrayProperty(user_props, "vertex_normals", 0);
+	m_prop_vert_flag = OCharArrayProperty(user_props, "vertex_flag", 0);
+	m_prop_vert_bweight = OCharArrayProperty(user_props, "vertex_bweight", 0);
+	
 	m_prop_edge_verts = OUInt32ArrayProperty(user_props, "edge_verts", 0);
 	m_prop_edge_flag = OInt16ArrayProperty(user_props, "edge_flag", 0);
 	m_prop_edge_crease = OCharArrayProperty(user_props, "edge_crease", 0);
 	m_prop_edge_bweight = OCharArrayProperty(user_props, "edge_bweight", 0);
-	m_prop_edges_index = OInt32ArrayProperty(user_props, "edges_index", 0);
-	m_param_poly_normals = ON3fGeomParam(geom_props, "poly_normals", false, kUniformScope, 1, 0);
-	m_param_vertex_normals = ON3fGeomParam(geom_props, "vertex_normals", false, kVertexScope, 1, 0);
+	
+	m_prop_poly_mat_nr = OInt16ArrayProperty(user_props, "poly_mat_nr", 0);
+	m_prop_poly_flag = OCharArrayProperty(user_props, "poly_flag", 0);
+	
+	m_prop_loop_verts = OInt32ArrayProperty(user_props, "loop_verts", 0);
+	m_prop_loop_edges = OInt32ArrayProperty(user_props, "loop_edges", 0);
 }
 
 /* XXX modifiers are not allowed to generate poly normals on their own!
@@ -104,101 +137,75 @@ static void ensure_normal_data(DerivedMesh *dm)
 }
 #endif
 
-void AbcDerivedMeshWriter::write_sample_edges(DerivedMesh *dm)
-{
-	MEdge *me, *medges = dm->getEdgeArray(dm);
-	int i, totedge = dm->getNumEdges(dm);
-	
-	std::vector<uint32_t> data_edge_verts;
-	std::vector<int16_t> data_edge_flag;
-	std::vector<int8_t> data_edge_crease;
-	std::vector<int8_t> data_edge_bweight;
-	data_edge_verts.reserve(totedge * 2);
-	data_edge_flag.reserve(totedge);
-	data_edge_crease.reserve(totedge);
-	data_edge_bweight.reserve(totedge);
-	
-	for (i = 0, me = medges; i < totedge; ++i, ++me) {
-		data_edge_verts.push_back(me->v1);
-		data_edge_verts.push_back(me->v2);
-		data_edge_flag.push_back(me->flag);
-		data_edge_crease.push_back(me->crease);
-		data_edge_bweight.push_back(me->bweight);
-	}
-	
-	m_prop_edge_verts.set(UInt32ArraySample(data_edge_verts));
-	m_prop_edge_flag.set(Int16ArraySample(data_edge_flag));
-	m_prop_edge_crease.set(CharArraySample(data_edge_crease));
-	m_prop_edge_bweight.set(CharArraySample(data_edge_bweight));
-}
-
-static P3fArraySample create_sample_positions(DerivedMesh *dm, std::vector<V3f> &data)
+static void create_sample_verts(DerivedMesh *dm, MVertSample &sample)
 {
 	MVert *mv, *mverts = dm->getVertArray(dm);
 	int i, totvert = dm->getNumVerts(dm);
 	
-	data.reserve(totvert);
+	sample.co.reserve(totvert);
+	sample.no.reserve(totvert);
+	sample.flag.reserve(totvert);
+	sample.bweight.reserve(totvert);
 	for (i = 0, mv = mverts; i < totvert; ++i, ++mv) {
-		float *co = mv->co;
-		data.push_back(V3f(co[0], co[1], co[2]));
+		float nor[3];
+		
+		sample.co.push_back(V3f(mv->co[0], mv->co[1], mv->co[2]));
+		
+		normal_short_to_float_v3(nor, mv->no);
+		sample.no.push_back(N3f(nor[0], nor[1], nor[2]));
+		
+		sample.flag.push_back(mv->flag);
+		sample.bweight.push_back(mv->bweight);
 	}
-	
-	return P3fArraySample(data);
 }
 
-static Int32ArraySample create_sample_vertex_indices(DerivedMesh *dm, std::vector<int> &data)
+static void create_sample_edges(DerivedMesh *dm, MEdgeSample &sample)
 {
-	MLoop *ml, *mloops = dm->getLoopArray(dm);
-	int i, totloop = dm->getNumLoops(dm);
-	
-	data.reserve(totloop);
-	for (i = 0, ml = mloops; i < totloop; ++i, ++ml) {
-		data.push_back(ml->v);
-	}
+	MEdge *me, *medges = dm->getEdgeArray(dm);
+	int i, totedge = dm->getNumEdges(dm);
 	
-	return Int32ArraySample(data);
-}
-
-static Int32ArraySample create_sample_loop_counts(DerivedMesh *dm, std::vector<int> &data)
-{
-	MPoly *mp, *mpolys = dm->getPolyArray(dm);
-	int i, totpoly = dm->getNumPolys(dm);
+	sample.verts.reserve(totedge * 2);
+	sample.flag.reserve(totedge);
+	sample.crease.reserve(totedge);
+	sample.bweight.reserve(totedge);
 	
-	data.reserve(totpoly);
-	for (i = 0, mp = mpolys; i < totpoly; ++i, ++mp) {
-		data.push_back(mp->totloop);
+	for (i = 0, me = medges; i < totedge; ++i, ++me) {
+		sample.verts.push_back(me->v1);
+		sample.verts.push_back(me->v2);
+		sample.flag.push_back(me->flag);
+		sample.crease.push_back(me->crease);
+		sample.bweight.push_back(me->bweight);
 	}
-	
-	return Int32ArraySample(data);
 }
 
-static OBoolGeomParam::Sample create_sample_poly_smooth(DerivedMesh *dm, std::vector<bool_t> &data)
+static void create_sample_polys(DerivedMesh *dm, MPolySample &sample)
 {
 	MPoly *mp, *mpolys = dm->getPolyArray(dm);
 	int i, totpoly = dm->getNumPolys(dm);
 	
-	data.reserve(totpoly);
+	sample.totloop.reserve(totpoly);
+	sample.mat_nr.reserve(totpoly);
+	sample.flag.reserve(totpoly);
+	
 	for (i = 0, mp = mpolys; i < totpoly; ++i, ++mp) {
-		data.push_back((bool)(mp->flag & ME_SMOOTH));
+		sample.totloop.push_back(mp->totloop);
+		sample.mat_nr.push_back(mp->mat_nr);
+		sample.flag.push_back(mp->flag);
 	}
-	
-	OBoolGeomParam::Sample sample;
-	sample.setVals(BoolArraySample(data));
-	sample.setScope(kUniformScope);
-	return sample;
 }
 
-static OInt32ArrayProperty::sample_type create_sample_edge_indices(DerivedMesh *dm, std::vector<int> &data)
+static void create_sample_loops(DerivedMesh *dm, MLoopSample &sample)
 {
 	MLoop *ml, *mloops = dm->getLoopArray(dm);
 	int i, totloop = dm->getNumLoops(dm);
 	
-	data.reserve(totloop);
+	sample.verts.reserve(totloop);
+	sample.edges.reserve(totloop);
+	
 	for (i = 0, ml = mloops; i < totloop; ++i, ++ml) {
-		data.push_back(ml->e);
+		sample.verts.push_back(ml->v);
+		sample.edges.push_back(ml->e);
 	}
-	
-	return OInt32ArrayProperty::sample_type(data);
 }
 
 static N3fArraySample create_sample_loop_normals(DerivedMesh *dm, std::vector<N3f> &data)
@@ -221,42 +228,6 @@ static N3fArraySample create_sample_loop_normals(DerivedMesh *dm, std::vector<N3
 	return N3fArraySample(data);
 }
 
-static N3fArraySample create_sample_poly_normals(DerivedMesh *dm, std::vector<N3f> &data)
-{
-	CustomData *cdata = dm->getPolyDataLayout(dm);
-	float (*nor)[3], (*polynors)[3];
-	int i, totpoly = dm->getNumPolys(dm);
-	
-	if (!CustomData_has_layer(cdata, CD_NORMAL))
-		return N3fArraySample();
-	
-	polynors = (float (*)[3])CustomData_get_layer(cdata, CD_NORMAL);
-	
-	data.reserve(totpoly);
-	for (i = 0, nor = polynors; i < totpoly; ++i, ++nor) {
-		float *vec = *nor;
-		data.push_back(N3f(vec[0], vec[1], vec[2]));
-	}
-	
-	return N3fArraySample(data);
-}
-
-static N3fArraySample create_sample_vertex_normals(DerivedMesh *dm, std::vector<N3f> &data)
-{
-	MVert *mv, *mverts = dm->getVertArray(dm);
-	int i, totvert = dm->getNumVerts(dm);
-	
-	data.reserve(totvert);
-	for (i = 0, mv = mverts; i < totvert; ++i, ++mv) {
-		float nor[3];
-		
-		normal_short_to_float_v3(nor, mv->no);
-		data.push_back(N3f(nor[0], nor[1], nor[2]));
-	}
-	
-	return N3fArraySample(data);
-}
-
 void AbcDerivedMeshWriter::write_sample()
 {
 	if (!m_mesh)
@@ -273,49 +244,45 @@ void AbcDerivedMeshWriter::write_sample()
 	OPolyMeshSchema &schema = m_mesh.getSchema();
 	OCompoundProperty user_props = schema.getUserProperties();
 	
-	std::vector<V3f> positions_buffer;
-	std::vector<int> indices_buffer;
-	std::vector<int> counts_buffer;
-	std::vector<bool_t> smooth_buffer;
-	std::vector<int> edges_index_buffer;
+	MVertSample vert_sample;
+	MEdgeSample edge_sample;
+	MPolySample poly_sample;
+	MLoopSample loop_sample;
+	
 	std::vector<N3f> loop_normals_buffer;
-	std::vector<N3f> poly_normals_buffer;
-	std::vector<N3f> vertex_normals_buffer;
-//	std::vector<V2f> uvs;
-//	V2fArraySample()
 	
 	// TODO decide how to handle vertex/face normals, in caching vs. export ...
-//	std::vector<V2f> uvs;
-//	OV2fGeomParam::Sample uvs(V2fArraySample(uvs), kFacevaryingScope );
-	
-	P3fArraySample positions = create_sample_positions(output_dm, positions_buffer);
-	Int32ArraySample indices = create_sample_vertex_indices(output_dm, indices_buffer);
-	Int32ArraySample counts = create_sample_loop_counts(output_dm, counts_buffer);
-	OBoolGeomParam::Sample smooth = create_sample_poly_smooth(output_dm, smooth_buffer);
-	OInt32ArrayProperty::sample_type edges_index = create_sample_edge_indices(output_dm, edges_index_buffer);
+	
+	create_sample_verts(output_dm, vert_sample);
+	create_sample_edges(output_dm, edge_sample);
+	create_sample_polys(output_dm, poly_sample);
+	create_sample_loops(output_dm, loop_sample);
+	
 	N3fArraySample lnormals = create_sample_loop_normals(output_dm, loop_normals_buffer

@@ Diff output truncated at 10240 characters. @@




More information about the Bf-blender-cvs mailing list