[Bf-blender-cvs] [e290a0b0568] blender2.7: Cleanup: add asserts to catch cases where wrong attribute type is used.

[Brecht Van Lommel]

Commit: e290a0b0568ecfcf47aa55b059de468b2c651e19
Author: Brecht Van Lommel
Date:   Tue Mar 5 18:49:47 2019 +0100
Branches: blender2.7
https://developer.blender.org/rBe290a0b0568ecfcf47aa55b059de468b2c651e19

Cleanup: add asserts to catch cases where wrong attribute type is used.

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

M	intern/cycles/render/attribute.cpp
M	intern/cycles/render/attribute.h

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

diff --git a/intern/cycles/render/attribute.cpp b/intern/cycles/render/attribute.cpp
index 70f75a4b573..0ce30b3bca6 100644
--- a/intern/cycles/render/attribute.cpp
+++ b/intern/cycles/render/attribute.cpp
@@ -69,6 +69,8 @@ void Attribute::resize(size_t num_elements)
 
 void Attribute::add(const float& f)
 {
+	assert(data_sizeof() == sizeof(float));
+
 	char *data = (char*)&f;
 	size_t size = sizeof(f);
 
@@ -78,6 +80,19 @@ void Attribute::add(const float& f)
 
 void Attribute::add(const uchar4& f)
 {
+	assert(data_sizeof() == sizeof(uchar4));
+
+	char *data = (char*)&f;
+	size_t size = sizeof(f);
+
+	for(size_t i = 0; i < size; i++)
+		buffer.push_back(data[i]);
+}
+
+void Attribute::add(const float2& f)
+{
+	assert(data_sizeof() == sizeof(float2));
+
 	char *data = (char*)&f;
 	size_t size = sizeof(f);
 
@@ -87,6 +102,8 @@ void Attribute::add(const uchar4& f)
 
 void Attribute::add(const float3& f)
 {
+	assert(data_sizeof() == sizeof(float3));
+
 	char *data = (char*)&f;
 	size_t size = sizeof(f);
 
@@ -96,6 +113,8 @@ void Attribute::add(const float3& f)
 
 void Attribute::add(const Transform& f)
 {
+	assert(data_sizeof() == sizeof(Transform));
+
 	char *data = (char*)&f;
 	size_t size = sizeof(f);
 
@@ -105,6 +124,8 @@ void Attribute::add(const Transform& f)
 
 void Attribute::add(const VoxelAttribute& f)
 {
+	assert(data_sizeof() == sizeof(VoxelAttribute));
+
 	char *data = (char*)&f;
 	size_t size = sizeof(f);
 
@@ -128,6 +149,8 @@ size_t Attribute::data_sizeof() const
 		return sizeof(uchar4);
 	else if(type == TypeDesc::TypeFloat)
 		return sizeof(float);
+	else if(type == TypeFloat2)
+		return sizeof(float2);
 	else if(type == TypeDesc::TypeMatrix)
 		return sizeof(Transform);
 	else
diff --git a/intern/cycles/render/attribute.h b/intern/cycles/render/attribute.h
index 9a92d98b713..ed9e9fe76d6 100644
--- a/intern/cycles/render/attribute.h
+++ b/intern/cycles/render/attribute.h
@@ -66,22 +66,80 @@ public:
 	size_t element_size(Mesh *mesh, AttributePrimitive prim) const;
 	size_t buffer_size(Mesh *mesh, AttributePrimitive prim) const;
 
-	char *data() { return (buffer.size())? &buffer[0]: NULL; };
-	float2 *data_float2() { return (float2*)data(); }
-	float3 *data_float3() { return (float3*)data(); }
-	float4 *data_float4() { return (float4*)data(); }
-	float *data_float() { return (float*)data(); }
-	uchar4 *data_uchar4() { return (uchar4*)data(); }
-	Transform *data_transform() { return (Transform*)data(); }
-	VoxelAttribute *data_voxel()  { return ( VoxelAttribute*)data(); }
-
-	const char *data() const { return (buffer.size())? &buffer[0]: NULL; }
-	const float2 *data_float2() const { return (const float2*)data(); }
-	const float3 *data_float3() const { return (const float3*)data(); }
-	const float4 *data_float4() const { return (const float4*)data(); }
-	const float *data_float() const { return (const float*)data(); }
-	const Transform *data_transform() const { return (const Transform*)data(); }
-	const VoxelAttribute *data_voxel() const { return (const VoxelAttribute*)data(); }
+	char *data()
+	{
+		return (buffer.size())? &buffer[0]: NULL;
+	}
+	float2 *data_float2()
+	{
+		assert(data_sizeof() == sizeof(float2));
+		return (float2*)data();
+	}
+	float3 *data_float3()
+	{
+		assert(data_sizeof() == sizeof(float3));
+		return (float3*)data();
+	}
+	float4 *data_float4()
+	{
+		assert(data_sizeof() == sizeof(float4));
+		return (float4*)data();
+	}
+	float *data_float()
+	{
+		assert(data_sizeof() == sizeof(float));
+		return (float*)data();
+	}
+	uchar4 *data_uchar4()
+	{
+		assert(data_sizeof() == sizeof(uchar4));
+		return (uchar4*)data();
+	}
+	Transform *data_transform()
+	{
+		assert(data_sizeof() == sizeof(Transform));
+		return (Transform*)data();
+	}
+	VoxelAttribute *data_voxel()
+	{
+		assert(data_sizeof() == sizeof(VoxelAttribute));
+		return ( VoxelAttribute*)data();
+	}
+
+	const char *data() const
+	{
+		return (buffer.size())? &buffer[0]: NULL;
+	}
+	const float2 *data_float2() const
+	{
+		assert(data_sizeof() == sizeof(float2));
+		return (const float2*)data();
+	}
+	const float3 *data_float3() const
+	{
+		assert(data_sizeof() == sizeof(float3));
+		return (const float3*)data();
+	}
+	const float4 *data_float4() const
+	{
+		assert(data_sizeof() == sizeof(float4));
+		return (const float4*)data();
+	}
+	const float *data_float() const
+	{
+		assert(data_sizeof() == sizeof(float));
+		return (const float*)data();
+	}
+	const Transform *data_transform() const
+	{
+		assert(data_sizeof() == sizeof(Transform));
+		return (const Transform*)data();
+	}
+	const VoxelAttribute *data_voxel() const
+	{
+		assert(data_sizeof() == sizeof(VoxelAttribute));
+		return (const VoxelAttribute*)data();
+	}
 
 	void zero_data(void* dst);
 	void add_with_weight(void* dst, void* src, float weight);