[Bf-blender-cvs] [462d9e37ea4] blender2.8: Cleanup: remove type prefix from render-data vars

Campbell Barton noreply at git.blender.org
Thu Apr 20 08:24:02 CEST 2017


Commit: 462d9e37ea4d4f9aa5344b4a49d9aa95f7692a10
Author: Campbell Barton
Date:   Thu Apr 20 16:24:35 2017 +1000
Branches: blender2.8
https://developer.blender.org/rB462d9e37ea4d4f9aa5344b4a49d9aa95f7692a10

Cleanup: remove type prefix from render-data vars

Render data is never mixed with other object types,
no need to make a distinction.

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

M	source/blender/blenkernel/intern/curve_render.c
M	source/blender/blenkernel/intern/lattice_render.c
M	source/blender/blenkernel/intern/mesh_render.c

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

diff --git a/source/blender/blenkernel/intern/curve_render.c b/source/blender/blenkernel/intern/curve_render.c
index 18fe02be5b4..d2ca9ab7729 100644
--- a/source/blender/blenkernel/intern/curve_render.c
+++ b/source/blender/blenkernel/intern/curve_render.c
@@ -180,90 +180,90 @@ enum {
  */
 static CurveRenderData *curve_render_data_create(Curve *cu, CurveCache *ob_curve_cache, const int types)
 {
-	CurveRenderData *lrdata = MEM_callocN(sizeof(*lrdata), __func__);
-	lrdata->types = types;
+	CurveRenderData *rdata = MEM_callocN(sizeof(*rdata), __func__);
+	rdata->types = types;
 	ListBase *nurbs;
 
-	lrdata->hide_handles = (cu->drawflag & CU_HIDE_HANDLES) != 0;
-	lrdata->hide_normals = (cu->drawflag & CU_HIDE_NORMALS) != 0;
+	rdata->hide_handles = (cu->drawflag & CU_HIDE_HANDLES) != 0;
+	rdata->hide_normals = (cu->drawflag & CU_HIDE_NORMALS) != 0;
 
-	lrdata->actnu = cu->actnu;
-	lrdata->actvert = cu->actvert;
+	rdata->actnu = cu->actnu;
+	rdata->actvert = cu->actvert;
 
-	lrdata->ob_curve_cache = ob_curve_cache;
+	rdata->ob_curve_cache = ob_curve_cache;
 
 	if (types & CU_DATATYPE_WIRE) {
 		curve_render_wire_verts_edges_len_get(
-		        lrdata->ob_curve_cache,
-		        &lrdata->wire.vert_len, &lrdata->wire.edge_len);
+		        rdata->ob_curve_cache,
+		        &rdata->wire.vert_len, &rdata->wire.edge_len);
 	}
 
 	if (cu->editnurb) {
 		EditNurb *editnurb = cu->editnurb;
 		nurbs = &editnurb->nurbs;
 
-		lrdata->edit_latt = editnurb;
+		rdata->edit_latt = editnurb;
 
 		if (types & CU_DATATYPE_OVERLAY) {
 			curve_render_overlay_verts_edges_len_get(
-			        nurbs, lrdata->hide_handles,
-			        &lrdata->overlay.vert_len,
-			        lrdata->hide_handles ? NULL : &lrdata->overlay.edge_len);
+			        nurbs, rdata->hide_handles,
+			        &rdata->overlay.vert_len,
+			        rdata->hide_handles ? NULL : &rdata->overlay.edge_len);
 
-			lrdata->actnu = cu->actnu;
-			lrdata->actvert = cu->actvert;
+			rdata->actnu = cu->actnu;
+			rdata->actvert = cu->actvert;
 		}
 		if (types & CU_DATATYPE_NORMAL) {
-			lrdata->normal.len = curve_render_normal_len_get(nurbs, lrdata->ob_curve_cache);
+			rdata->normal.len = curve_render_normal_len_get(nurbs, rdata->ob_curve_cache);
 		}
 	}
 	else {
 		nurbs = &cu->nurb;
 	}
 
-	lrdata->nurbs = nurbs;
+	rdata->nurbs = nurbs;
 
-	return lrdata;
+	return rdata;
 }
 
-static void curve_render_data_free(CurveRenderData *lrdata)
+static void curve_render_data_free(CurveRenderData *rdata)
 {
 #if 0
-	if (lrdata->loose_verts) {
-		MEM_freeN(lrdata->loose_verts);
+	if (rdata->loose_verts) {
+		MEM_freeN(rdata->loose_verts);
 	}
 #endif
-	MEM_freeN(lrdata);
+	MEM_freeN(rdata);
 }
 
-static int curve_render_data_overlay_verts_len_get(const CurveRenderData *lrdata)
+static int curve_render_data_overlay_verts_len_get(const CurveRenderData *rdata)
 {
-	BLI_assert(lrdata->types & CU_DATATYPE_OVERLAY);
-	return lrdata->overlay.vert_len;
+	BLI_assert(rdata->types & CU_DATATYPE_OVERLAY);
+	return rdata->overlay.vert_len;
 }
 
-static int curve_render_data_overlay_edges_len_get(const CurveRenderData *lrdata)
+static int curve_render_data_overlay_edges_len_get(const CurveRenderData *rdata)
 {
-	BLI_assert(lrdata->types & CU_DATATYPE_OVERLAY);
-	return lrdata->overlay.edge_len;
+	BLI_assert(rdata->types & CU_DATATYPE_OVERLAY);
+	return rdata->overlay.edge_len;
 }
 
-static int curve_render_data_wire_verts_len_get(const CurveRenderData *lrdata)
+static int curve_render_data_wire_verts_len_get(const CurveRenderData *rdata)
 {
-	BLI_assert(lrdata->types & CU_DATATYPE_WIRE);
-	return lrdata->wire.vert_len;
+	BLI_assert(rdata->types & CU_DATATYPE_WIRE);
+	return rdata->wire.vert_len;
 }
 
-static int curve_render_data_wire_edges_len_get(const CurveRenderData *lrdata)
+static int curve_render_data_wire_edges_len_get(const CurveRenderData *rdata)
 {
-	BLI_assert(lrdata->types & CU_DATATYPE_WIRE);
-	return lrdata->wire.edge_len;
+	BLI_assert(rdata->types & CU_DATATYPE_WIRE);
+	return rdata->wire.edge_len;
 }
 
-static int curve_render_data_normal_len_get(const CurveRenderData *lrdata)
+static int curve_render_data_normal_len_get(const CurveRenderData *rdata)
 {
-	BLI_assert(lrdata->types & CU_DATATYPE_NORMAL);
-	return lrdata->normal.len;
+	BLI_assert(rdata->types & CU_DATATYPE_NORMAL);
+	return rdata->normal.len;
 }
 
 enum {
@@ -442,10 +442,10 @@ void BKE_curve_batch_cache_free(Curve *cu)
 }
 
 /* Batch cache usage. */
-static VertexBuffer *curve_batch_cache_get_wire_verts(CurveRenderData *lrdata, CurveBatchCache *cache)
+static VertexBuffer *curve_batch_cache_get_wire_verts(CurveRenderData *rdata, CurveBatchCache *cache)
 {
-	BLI_assert(lrdata->types & CU_DATATYPE_WIRE);
-	BLI_assert(lrdata->ob_curve_cache != NULL);
+	BLI_assert(rdata->types & CU_DATATYPE_WIRE);
+	BLI_assert(rdata->ob_curve_cache != NULL);
 
 	if (cache->wire.verts == NULL) {
 		static VertexFormat format = { 0 };
@@ -455,12 +455,12 @@ static VertexBuffer *curve_batch_cache_get_wire_verts(CurveRenderData *lrdata, C
 			pos_id = VertexFormat_add_attrib(&format, "pos", COMP_F32, 3, KEEP_FLOAT);
 		}
 
-		const int vert_len = curve_render_data_wire_verts_len_get(lrdata);
+		const int vert_len = curve_render_data_wire_verts_len_get(rdata);
 
 		VertexBuffer *vbo = cache->wire.verts = VertexBuffer_create_with_format(&format);
 		VertexBuffer_allocate_data(vbo, vert_len);
 		int vbo_len_used = 0;
-		for (const BevList *bl = lrdata->ob_curve_cache->bev.first; bl; bl = bl->next) {
+		for (const BevList *bl = rdata->ob_curve_cache->bev.first; bl; bl = bl->next) {
 			if (bl->nr > 0) {
 				const int i_end = vbo_len_used + bl->nr;
 				for (const BevPoint *bevp = bl->bevpoints; vbo_len_used < i_end; vbo_len_used++, bevp++) {
@@ -474,21 +474,21 @@ static VertexBuffer *curve_batch_cache_get_wire_verts(CurveRenderData *lrdata, C
 	return cache->wire.verts;
 }
 
-static ElementList *curve_batch_cache_get_wire_edges(CurveRenderData *lrdata, CurveBatchCache *cache)
+static ElementList *curve_batch_cache_get_wire_edges(CurveRenderData *rdata, CurveBatchCache *cache)
 {
-	BLI_assert(lrdata->types & CU_DATATYPE_WIRE);
-	BLI_assert(lrdata->ob_curve_cache != NULL);
+	BLI_assert(rdata->types & CU_DATATYPE_WIRE);
+	BLI_assert(rdata->ob_curve_cache != NULL);
 
 	if (cache->wire.edges == NULL) {
-		const int vert_len = curve_render_data_wire_verts_len_get(lrdata);
-		const int edge_len = curve_render_data_wire_edges_len_get(lrdata);
+		const int vert_len = curve_render_data_wire_verts_len_get(rdata);
+		const int edge_len = curve_render_data_wire_edges_len_get(rdata);
 		int edge_len_used = 0;
 
 		ElementListBuilder elb;
 		ElementListBuilder_init(&elb, PRIM_LINES, edge_len, vert_len);
 
 		int i = 0;
-		for (const BevList *bl = lrdata->ob_curve_cache->bev.first; bl; bl = bl->next) {
+		for (const BevList *bl = rdata->ob_curve_cache->bev.first; bl; bl = bl->next) {
 			if (bl->nr > 0) {
 				const bool is_cyclic = bl->poly != -1;
 				const int i_end = i + (bl->nr);
@@ -507,7 +507,7 @@ static ElementList *curve_batch_cache_get_wire_edges(CurveRenderData *lrdata, Cu
 			}
 		}
 
-		if (lrdata->hide_handles) {
+		if (rdata->hide_handles) {
 			BLI_assert(edge_len_used <= edge_len);
 		}
 		else {
@@ -520,10 +520,10 @@ static ElementList *curve_batch_cache_get_wire_edges(CurveRenderData *lrdata, Cu
 	return cache->wire.elem;
 }
 
-static VertexBuffer *curve_batch_cache_get_normal_verts(CurveRenderData *lrdata, CurveBatchCache *cache)
+static VertexBuffer *curve_batch_cache_get_normal_verts(CurveRenderData *rdata, CurveBatchCache *cache)
 {
-	BLI_assert(lrdata->types & CU_DATATYPE_NORMAL);
-	BLI_assert(lrdata->ob_curve_cache != NULL);
+	BLI_assert(rdata->types & CU_DATATYPE_NORMAL);
+	BLI_assert(rdata->ob_curve_cache != NULL);
 
 	if (cache->normal.verts == NULL) {
 		static VertexFormat format = { 0 };
@@ -533,7 +533,7 @@ static VertexBuffer *curve_batch_cache_get_normal_verts(CurveRenderData *lrdata,
 			pos_id = VertexFormat_add_attrib(&format, "pos", COMP_F32, 3, KEEP_FLOAT);
 		}
 
-		const int normal_len = curve_render_data_normal_len_get(lrdata);
+		const int normal_len = curve_render_data_normal_len_get(rdata);
 		const int vert_len = normal_len * 3;
 
 		VertexBuffer *vbo = cache->normal.verts = VertexBuffer_create_with_format(&format);
@@ -543,7 +543,7 @@ static VertexBuffer *curve_batch_cache_get_normal_verts(CurveRenderData *lrdata,
 		const BevList *bl;
 		const Nurb *nu;
 
-		for (bl = lrdata->ob_curve_cache->bev.first, nu = lrdata->nurbs->first;
+		for (bl = rdata->ob_curve_cache->bev.first, nu = rdata->nurbs->first;
 		     nu && bl;
 		     bl = bl->next, nu = nu->next)
 		{
@@ -586,13 +586,13 @@ static VertexBuffer *curve_batch_cache_get_normal_verts(CurveRenderData *lrdata,
 	return cache->normal.verts;
 }
 
-static ElementList *curve_batch_cache_get_normal_edges(CurveRenderData *lrdata, CurveBatchCache *cache)
+static ElementList *curve_batch_cache_get_normal_edges(CurveRenderData *rdata, CurveBatchCache *cache)
 {
-	BLI_assert(lrdata->types & CU_DATATYPE_NORMAL);
-	BLI_assert(lrdata->ob_curve_cache != NULL);
+	BLI_assert(rdata->types & CU_DATATYPE_NORMAL);
+	BLI_assert(rdata->ob_curve_cache != NULL);
 
 	if (cache->normal.edges == NULL) {
-		const int normal_len = curve_render_data_normal_len_get(lrdata);
+		const int normal_len = curve_render_data_normal_len_get(rdata);
 		const int edge_len = normal_len * 2;
 
 		ElementListBuilder elb;
@@ -619,7 +619,7 @@ static void curve_batch_cache_create_overlay_batches(Curve *cu)
 	int options = CU_DATATYPE_OVERLAY;
 
 	CurveBatchCache *cache = curve_batch_cache_get(cu);
-	CurveRenderData *lrdata = curve_render_data_create(cu, NULL, options);
+	CurveRenderData *rdata = curve_render_data_create(cu, NULL, options);
 
 	if (cache->overlay.verts == NULL) {
 		static VertexFormat format = { 0 };
@@ -631,19 +631,19 @@ static void curve_batch_cache_create_overlay_batches(Curve *cu)
 		}
 
 		VertexBuffer *vbo = VertexBuffer_create_with_format(&format);
-		const int vbo_len_capacity = curve_render_data_overlay_verts_len_get(lrdata);
+		const int vbo_len_capacity = curve_render_data_overlay_verts_len_get(rdata);
 		int vbo_len_used = 0;
 		VertexBuffer_allocate_data(vbo, vbo_len_capacity);
 		int i = 0;
-		for (Nurb *nu = lrdat

@@ Diff output truncated at 10240 characters. @@




More information about the Bf-blender-cvs mailing list