Cleanup: add asserts to catch cases where wrong attribute type is used.
authorBrecht Van Lommel <brechtvanlommel@gmail.com>
Tue, 5 Mar 2019 17:49:47 +0000 (18:49 +0100)
committerBrecht Van Lommel <brechtvanlommel@gmail.com>
Tue, 5 Mar 2019 18:05:24 +0000 (19:05 +0100)
intern/cycles/render/attribute.cpp
intern/cycles/render/attribute.h

index 70f75a4b573e6d2a16c70a37484416b9f52648f0..0ce30b3bca639b9ea770458ea70ed40686eeaf89 100644 (file)
@@ -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
index 9a92d98b713f1419cfe8aec21e80ecd1f71efb8c..ed9e9fe76d6f84ada45b70268721fd34457b77e0 100644 (file)
@@ -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);