diff --git a/core/include/Context.h b/core/include/Context.h
index 73f346fcd..0f7e625f5 100755
--- a/core/include/Context.h
+++ b/core/include/Context.h
@@ -612,9 +612,241 @@ namespace helios {
 
         bool ishidden = false;
 
-        friend class Context;
+    friend class Context;
     };
 
+    //---- Template Implementations for Primitive ----//
+
+    template <typename T>
+    void Primitive::setPrimitiveData(const char *label, const T &data) {
+        static_assert(
+            std::is_same_v<T, int> || std::is_same_v<T, uint> || std::is_same_v<T, float> ||
+            std::is_same_v<T, double> || std::is_same_v<T, vec2> || std::is_same_v<T, vec3> ||
+            std::is_same_v<T, vec4> || std::is_same_v<T, int2> || std::is_same_v<T, int3> ||
+            std::is_same_v<T, int4> || std::is_same_v<T, std::string>,
+            "Invalid primitive data type");
+
+        if constexpr (std::is_same_v<T, int>) {
+            primitive_data_int[label] = {data};
+            primitive_data_types[label] = HELIOS_TYPE_INT;
+        } else if constexpr (std::is_same_v<T, uint>) {
+            primitive_data_uint[label] = {data};
+            primitive_data_types[label] = HELIOS_TYPE_UINT;
+        } else if constexpr (std::is_same_v<T, float>) {
+            primitive_data_float[label] = {data};
+            primitive_data_types[label] = HELIOS_TYPE_FLOAT;
+        } else if constexpr (std::is_same_v<T, double>) {
+            primitive_data_double[label] = {data};
+            primitive_data_types[label] = HELIOS_TYPE_DOUBLE;
+        } else if constexpr (std::is_same_v<T, vec2>) {
+            primitive_data_vec2[label] = {data};
+            primitive_data_types[label] = HELIOS_TYPE_VEC2;
+        } else if constexpr (std::is_same_v<T, vec3>) {
+            primitive_data_vec3[label] = {data};
+            primitive_data_types[label] = HELIOS_TYPE_VEC3;
+        } else if constexpr (std::is_same_v<T, vec4>) {
+            primitive_data_vec4[label] = {data};
+            primitive_data_types[label] = HELIOS_TYPE_VEC4;
+        } else if constexpr (std::is_same_v<T, int2>) {
+            primitive_data_int2[label] = {data};
+            primitive_data_types[label] = HELIOS_TYPE_INT2;
+        } else if constexpr (std::is_same_v<T, int3>) {
+            primitive_data_int3[label] = {data};
+            primitive_data_types[label] = HELIOS_TYPE_INT3;
+        } else if constexpr (std::is_same_v<T, int4>) {
+            primitive_data_int4[label] = {data};
+            primitive_data_types[label] = HELIOS_TYPE_INT4;
+        } else if constexpr (std::is_same_v<T, std::string>) {
+            primitive_data_string[label] = {data};
+            primitive_data_types[label] = HELIOS_TYPE_STRING;
+        }
+        dirty_flag = true;
+    }
+
+    template <typename T>
+    void Primitive::getPrimitiveData(const char *label, T &data) const {
+#ifdef HELIOS_DEBUG
+        if (!doesPrimitiveDataExist(label)) {
+            helios_runtime_error("ERROR (Primitive::getPrimitiveData): Primitive data " +
+                                 std::string(label) + " does not exist for primitive " +
+                                 std::to_string(UUID));
+        }
+#endif
+
+        HeliosDataType type = primitive_data_types.at(label);
+
+        if constexpr (std::is_same_v<T, int>) {
+            if (type == HELIOS_TYPE_INT) {
+                data = primitive_data_int.at(label).front();
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type int, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type int.");
+            }
+        } else if constexpr (std::is_same_v<T, uint>) {
+            if (type == HELIOS_TYPE_UINT) {
+                data = primitive_data_uint.at(label).front();
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type uint, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type uint.");
+            }
+        } else if constexpr (std::is_same_v<T, float>) {
+            if (type == HELIOS_TYPE_FLOAT) {
+                data = primitive_data_float.at(label).front();
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type float, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type float.");
+            }
+        } else if constexpr (std::is_same_v<T, double>) {
+            if (type == HELIOS_TYPE_DOUBLE) {
+                data = primitive_data_double.at(label).front();
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type double, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type double.");
+            }
+        } else if constexpr (std::is_same_v<T, vec2>) {
+            if (type == HELIOS_TYPE_VEC2) {
+                data = primitive_data_vec2.at(label).front();
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type vec2, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type vec2.");
+            }
+        } else if constexpr (std::is_same_v<T, vec3>) {
+            if (type == HELIOS_TYPE_VEC3) {
+                data = primitive_data_vec3.at(label).front();
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type vec3, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type vec3.");
+            }
+        } else if constexpr (std::is_same_v<T, vec4>) {
+            if (type == HELIOS_TYPE_VEC4) {
+                data = primitive_data_vec4.at(label).front();
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type vec4, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type vec4.");
+            }
+        } else if constexpr (std::is_same_v<T, int2>) {
+            if (type == HELIOS_TYPE_INT2) {
+                data = primitive_data_int2.at(label).front();
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type int2, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type int2.");
+            }
+        } else if constexpr (std::is_same_v<T, int3>) {
+            if (type == HELIOS_TYPE_INT3) {
+                data = primitive_data_int3.at(label).front();
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type int3, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type int3.");
+            }
+        } else if constexpr (std::is_same_v<T, int4>) {
+            if (type == HELIOS_TYPE_INT4) {
+                data = primitive_data_int4.at(label).front();
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type int4, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type int4.");
+            }
+        } else if constexpr (std::is_same_v<T, std::string>) {
+            if (type == HELIOS_TYPE_STRING) {
+                data = primitive_data_string.at(label).front();
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type string, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type string.");
+            }
+        }
+    }
+
+    template <typename T>
+    void Primitive::getPrimitiveData(const char *label, std::vector<T> &data) const {
+#ifdef HELIOS_DEBUG
+        if (!doesPrimitiveDataExist(label)) {
+            helios_runtime_error("ERROR (Primitive::getPrimitiveData): Primitive data " +
+                                 std::string(label) + " does not exist for primitive " +
+                                 std::to_string(UUID));
+        }
+#endif
+
+        HeliosDataType type = primitive_data_types.at(label);
+
+        if constexpr (std::is_same_v<T, int>) {
+            if (type == HELIOS_TYPE_INT) {
+                data = primitive_data_int.at(label);
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type int, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type int.");
+            }
+        } else if constexpr (std::is_same_v<T, uint>) {
+            if (type == HELIOS_TYPE_UINT) {
+                data = primitive_data_uint.at(label);
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type uint, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type uint.");
+            }
+        } else if constexpr (std::is_same_v<T, float>) {
+            if (type == HELIOS_TYPE_FLOAT) {
+                data = primitive_data_float.at(label);
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type float, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type float.");
+            }
+        } else if constexpr (std::is_same_v<T, double>) {
+            if (type == HELIOS_TYPE_DOUBLE) {
+                data = primitive_data_double.at(label);
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type double, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type double.");
+            }
+        } else if constexpr (std::is_same_v<T, vec2>) {
+            if (type == HELIOS_TYPE_VEC2) {
+                data = primitive_data_vec2.at(label);
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type vec2, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type vec2.");
+            }
+        } else if constexpr (std::is_same_v<T, vec3>) {
+            if (type == HELIOS_TYPE_VEC3) {
+                data = primitive_data_vec3.at(label);
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type vec3, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type vec3.");
+            }
+        } else if constexpr (std::is_same_v<T, vec4>) {
+            if (type == HELIOS_TYPE_VEC4) {
+                data = primitive_data_vec4.at(label);
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type vec4, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type vec4.");
+            }
+        } else if constexpr (std::is_same_v<T, int2>) {
+            if (type == HELIOS_TYPE_INT2) {
+                data = primitive_data_int2.at(label);
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type int2, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type int2.");
+            }
+        } else if constexpr (std::is_same_v<T, int3>) {
+            if (type == HELIOS_TYPE_INT3) {
+                data = primitive_data_int3.at(label);
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type int3, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type int3.");
+            }
+        } else if constexpr (std::is_same_v<T, int4>) {
+            if (type == HELIOS_TYPE_INT4) {
+                data = primitive_data_int4.at(label);
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type int4, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type int4.");
+            }
+        } else if constexpr (std::is_same_v<T, std::string>) {
+            if (type == HELIOS_TYPE_STRING) {
+                data = primitive_data_string.at(label);
+            } else {
+                helios_runtime_error("ERROR (Primitive::getPrimitiveData): Attempted to get data for type string, but data " +
+                                     std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type string.");
+            }
+        }
+    }
+
     //! Tile compound object class
     class Tile final : public CompoundObject {
     public:
@@ -1147,82 +1379,14 @@ namespace helios {
 
         //-------- Primitive Data Methods ---------- //
 
-        //! Add data value (int) associated with a primitive element
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
-         */
-        void setPrimitiveData(const char *label, int data);
-
-        //! Add data value (uint) associated with a primitive element
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
-         */
-        void setPrimitiveData(const char *label, uint data);
-
-        //! Add data value (float) associated with a primitive element
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
-         */
-        void setPrimitiveData(const char *label, float data);
-
-        //! Add data value (double) associated with a primitive element
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
-         */
-        void setPrimitiveData(const char *label, double data);
-
-        //! Add data value (vec2) associated with a primitive element
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
-         */
-        void setPrimitiveData(const char *label, const helios::vec2 &data);
-
-        //! Add data value (vec3) associated with a primitive element
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
-         */
-        void setPrimitiveData(const char *label, const helios::vec3 &data);
-
-        //! Add data value (vec4) associated with a primitive element
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
-         */
-        void setPrimitiveData(const char *label, const helios::vec4 &data);
-
-        //! Add data value (int2) associated with a primitive element
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
-         */
-        void setPrimitiveData(const char *label, const helios::int2 &data);
-
-        //! Add data value (int3) associated with a primitive element
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
-         */
-        void setPrimitiveData(const char *label, const helios::int3 &data);
-
-        //! Add data value (int4) associated with a primitive element
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
-         */
-        void setPrimitiveData(const char *label, const helios::int4 &data);
-
-        //! Add data value (string) associated with a primitive element
+        //! Add data value associated with a primitive element
         /**
+         * \tparam T Primitive data type
          * \param[in] label Name/label associated with data
          * \param[in] data Primitive data value (scalar)
          */
-        void setPrimitiveData(const char *label, const std::string &data);
+        template <typename T>
+        void setPrimitiveData(const char *label, const T &data);
 
         //! Add (array) data associated with a primitive element
         /**
@@ -1234,159 +1398,23 @@ namespace helios {
          */
         void setPrimitiveData(const char *label, HeliosDataType type, uint size, void *data);
 
-        //! Get data associated with a primitive element (integer scalar)
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, int &data) const;
-
-        //! Get data associated with a primitive element (vector of integers)
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, std::vector<int> &data) const;
-
-        //! Get data associated with a primitive element (unsigned integer scalar)
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, uint &data) const;
-
-        //! Get data associated with a primitive element (vector of unsigned integers)
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, std::vector<uint> &data) const;
-
-        //! Get data associated with a primitive element (float scalar)
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, float &data) const;
-
-        //! Get data associated with a primitive element (vector of floats)
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, std::vector<float> &data) const;
-
-        //! Get data associated with a primitive element (double scalar)
-        /**
-         *  \param[in] label Name/label associated with data
-         *  \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, double &data) const;
-
-        //! Get data associated with a primitive element (vector of doubles)
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, std::vector<double> &data) const;
-
-        //! Get data associated with a primitive element (vec2 scalar)
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, vec2 &data) const;
-
-        //! Get data associated with a primitive element (vector of vec2's)
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, std::vector<vec2> &data) const;
-
-        //! Get data associated with a primitive element (vec3 scalar)
-        /**
-         *  \param[in] label Name/label associated with data
-         *  \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, vec3 &data) const;
-
-        //! Get data associated with a primitive element (vector of vec3's)
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, std::vector<vec3> &data) const;
-
-        //! Get data associated with a primitive element (vec4 scalar)
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, vec4 &data) const;
-
-        //! Get data associated with a primitive element (vector of vec4's)
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, std::vector<vec4> &data) const;
-
-        //! Get data associated with a primitive element (int2 scalar)
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, int2 &data) const;
-
-        //! Get data associated with a primitive element (vector of int2's)
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, std::vector<int2> &data) const;
-
-        //! Get data associated with a primitive element (int3 scalar)
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, int3 &data) const;
-
-        //! Get data associated with a primitive element (vector of int3's)
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, std::vector<int3> &data) const;
-
-        //! Get data associated with a primitive element (int4 scalar)
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, int4 &data) const;
-
-        //! Get data associated with a primitive element (vector of int4's)
-        /**
-         * \param[in] label Name/label associated with data
-         * \param[out] data Primitive data structure
-         */
-        void getPrimitiveData(const char *label, std::vector<int4> &data) const;
-
-        //! Get data associated with a primitive element (string scalar)
+        //! Get data associated with a primitive element
         /**
+         * \tparam T Primitive data type
          * \param[in] label Name/label associated with data
          * \param[out] data Primitive data structure
          */
-        void getPrimitiveData(const char *label, std::string &data) const;
+        template <typename T>
+        void getPrimitiveData(const char *label, T &data) const;
 
-        //! Get data associated with a primitive element (vector of strings)
+        //! Get vector data associated with a primitive element
         /**
+         * \tparam T Primitive data type
          * \param[in] label Name/label associated with data
          * \param[out] data Primitive data structure
          */
-        void getPrimitiveData(const char *label, std::vector<std::string> &data) const;
+        template <typename T>
+        void getPrimitiveData(const char *label, std::vector<T> &data) const;
 
         //! Get the Helios data type of primitive data
         /**
@@ -2707,22 +2735,26 @@ namespace helios {
 
         //-------- Primitive Data Methods ---------- //
 
-        //! Add data value (int) associated with a primitive element
+        //! Add data value associated with a primitive element
         /**
+         * \tparam T Primitive data type
          * \param[in] UUID Unique universal identifier of Primitive element
          * \param[in] label Name/label associated with data
          * \param[in] data Primitive data value (scalar)
          */
-        void setPrimitiveData(uint UUID, const char *label, int data);
+        template <typename T>
+        void setPrimitiveData(uint UUID, const char *label, const T &data);
 
-        //! Add data value (int) associated with a vector of primitive elements. Each element in UUIDs maps to each element in data.
+        //! Add data value associated with a vector of primitive elements. Each element in UUIDs maps to each element in data.
         /**
+         * \tparam T Primitive data type
          * \note the size of UUIDs and data must match
          * \param[in] UUIDs Unique universal identifiers of Primitive elements
          * \param[in] label Name/label associated with data
          * \param[in] data Primitive data value (vector)
          */
-        void setPrimitiveData(const std::vector<uint> &UUIDs, const char *label, const std::vector<int> &data);
+        template <typename T>
+        void setPrimitiveData(const std::vector<uint> &UUIDs, const char *label, const std::vector<T> &data);
 
         //! Add data value (uint) associated with a primitive element
         /**
@@ -2904,93 +2936,26 @@ namespace helios {
          */
         void setPrimitiveData(uint UUID, const char *label, HeliosDataType type, uint size, void *data);
 
-        //! Add data value (int) associated with a primitive element
-        /**
-         * \param[in] UUIDs Vector of unique universal identifiers of Primitive elements
-         * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
-         */
-        void setPrimitiveData(const std::vector<uint> &UUIDs, const char *label, const int &data);
-
-        //! Add data value (uint) associated with a primitive element
+        //! Add scalar data to multiple primitive elements
         /**
+         * \tparam T Primitive data type
          * \param[in] UUIDs Vector of unique universal identifiers of Primitive elements
          * \param[in] label Name/label associated with data
          * \param[in] data Primitive data value (scalar)
          */
-        void setPrimitiveData(const std::vector<uint> &UUIDs, const char *label, const uint &data);
+        template <typename T>
+        void setPrimitiveData(const std::vector<uint> &UUIDs, const char *label, const T &data);
 
-        //! Add data value (float) associated with a primitive element
-        /**
-         * \param[in] UUIDs Vector of unique universal identifiers of Primitive elements
-         * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
-         */
-        void setPrimitiveData(const std::vector<uint> &UUIDs, const char *label, const float &data);
-
-        //! Add data value (double) associated with a primitive element
-        /**
-         * \param[in] UUIDs Vector of unique universal identifiers of Primitive elements
-         * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
-         */
-        void setPrimitiveData(const std::vector<uint> &UUIDs, const char *label, const double &data);
-
-        //! Add data value (vec2) associated with a primitive element
-        /**
-         * \param[in] UUIDs Vector of unique universal identifiers of Primitive elements
-         * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
-         */
-        void setPrimitiveData(const std::vector<uint> &UUIDs, const char *label, const helios::vec2 &data);
-
-        //! Add data value (vec3) associated with a primitive element
-        /**
-         * \param[in] UUIDs Vector of unique universal identifiers of Primitive elements
-         * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
-         */
-        void setPrimitiveData(const std::vector<uint> &UUIDs, const char *label, const helios::vec3 &data);
-
-        //! Add data value (vec4) associated with a primitive element
-        /**
-         * \param[in] UUIDs Vector of unique universal identifiers of Primitive elements
-         * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
-         */
-        void setPrimitiveData(const std::vector<uint> &UUIDs, const char *label, const helios::vec4 &data);
-
-        //! Add data value (int2) associated with a primitive element
-        /**
-         * \param[in] UUIDs Vector of unique universal identifiers of Primitive elements
-         * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
-         */
-        void setPrimitiveData(const std::vector<uint> &UUIDs, const char *label, const helios::int2 &data);
-
-        //! Add data value (int3) associated with a primitive element
-        /**
-         * \param[in] UUIDs Vector of unique universal identifiers of Primitive elements
-         * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
-         */
-        void setPrimitiveData(const std::vector<uint> &UUIDs, const char *label, const helios::int3 &data);
-
-        //! Add data value (int4) associated with a primitive element
-        /**
-         * \param[in] UUIDs Vector of unique universal identifiers of Primitive elements
-         * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
-         */
-        void setPrimitiveData(const std::vector<uint> &UUIDs, const char *label, const helios::int4 &data);
-
-        //! Add data value (string) associated with a primitive element
+        //! Add vector data to multiple primitive elements
         /**
+         * \tparam T Primitive data type
+         * \note the size of UUIDs and data must match
          * \param[in] UUIDs Vector of unique universal identifiers of Primitive elements
          * \param[in] label Name/label associated with data
-         * \param[in] data Primitive data value (scalar)
+         * \param[in] data Primitive data value (vector)
          */
-        void setPrimitiveData(const std::vector<uint> &UUIDs, const char *label, const std::string &data);
+        template <typename T>
+        void setPrimitiveData(const std::vector<uint> &UUIDs, const char *label, const std::vector<T> &data);
 
         //! Add data value (int) associated with a primitive element
         /**
@@ -6855,6 +6820,63 @@ namespace helios {
         [[nodiscard]] std::vector<uint> filterObjectsByData(const std::vector<uint> &objIDs, const std::string &object_data_label, const std::string &filter_value) const;
     };
 
+    //---- Template Implementations for Context primitive data ----//
+
+    template <typename T>
+    void Context::setPrimitiveData(uint UUID, const char *label, const T &data) {
+#ifdef HELIOS_DEBUG
+        if (primitives.find(UUID) == primitives.end()) {
+            helios_runtime_error("ERROR (Context::setPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
+        }
+#endif
+        primitives.at(UUID)->setPrimitiveData(label, data);
+    }
+
+    template <typename T>
+    void Context::setPrimitiveData(const std::vector<uint> &UUIDs, const char *label, const std::vector<T> &data) {
+#ifdef HELIOS_DEBUG
+        if (UUIDs.size() != data.size()) {
+            helios_runtime_error("ERROR (Context::setPrimitiveData): UUIDs and data vectors must be the same size.");
+        }
+#endif
+#ifdef USE_OPENMP
+#pragma omp parallel for
+#endif
+        for (size_t i = 0; i < UUIDs.size(); ++i) {
+            primitives.at(UUIDs[i])->setPrimitiveData(label, data[i]);
+        }
+    }
+
+    template <typename T>
+    void Context::setPrimitiveData(const std::vector<uint> &UUIDs, const char *label, const T &data) {
+#ifdef USE_OPENMP
+#pragma omp parallel for
+#endif
+        for (uint id : UUIDs) {
+            primitives.at(id)->setPrimitiveData(label, data);
+        }
+    }
+
+    template <typename T>
+    void Context::getPrimitiveData(uint UUID, const char *label, T &data) const {
+#ifdef HELIOS_DEBUG
+        if (primitives.find(UUID) == primitives.end()) {
+            helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
+        }
+#endif
+        primitives.at(UUID)->getPrimitiveData(label, data);
+    }
+
+    template <typename T>
+    void Context::getPrimitiveData(uint UUID, const char *label, std::vector<T> &data) const {
+#ifdef HELIOS_DEBUG
+        if (primitives.find(UUID) == primitives.end()) {
+            helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
+        }
+#endif
+        primitives.at(UUID)->getPrimitiveData(label, data);
+    }
+
 
 } // namespace helios
 
diff --git a/core/include/global.h b/core/include/global.h
index 8caa63162..1c34de3bb 100755
--- a/core/include/global.h
+++ b/core/include/global.h
@@ -57,6 +57,7 @@ constexpr float PI_F = 3.14159265358979323846f;
 #include <thread>
 #include <iomanip>
 #include <filesystem>
+#include <type_traits>
 
 #ifdef USE_OPENMP
 #include <omp.h>
diff --git a/core/src/Context_data.cpp b/core/src/Context_data.cpp
index 8b37d5cda..bd7a31f20 100644
--- a/core/src/Context_data.cpp
+++ b/core/src/Context_data.cpp
@@ -19,1514 +19,124 @@ using namespace helios;
 
 // ------ Primitive Data -------- //
 
-void Primitive::setPrimitiveData(const char* label, int data){
-  primitive_data_int[label] = {data};
-  primitive_data_types[label] = HELIOS_TYPE_INT;
-    dirty_flag = true;
-}
-
-void Primitive::setPrimitiveData(const char* label, uint data){
-  primitive_data_uint[label] = {data};
-  primitive_data_types[label] = HELIOS_TYPE_UINT;
-    dirty_flag = true;
-}
-
-void Primitive::setPrimitiveData(const char* label, float data){
-  primitive_data_float[label] = {data};
-  primitive_data_types[label] = HELIOS_TYPE_FLOAT;
-    dirty_flag = true;
-}
-
-void Primitive::setPrimitiveData(const char* label, double data){
-  primitive_data_double[label] = {data};
-  primitive_data_types[label] = HELIOS_TYPE_DOUBLE;
-    dirty_flag = true;
-}
-
-void Primitive::setPrimitiveData( const char* label, const helios::vec2& data ){
-  primitive_data_vec2[label] = {data};
-  primitive_data_types[label] = HELIOS_TYPE_VEC2;
-    dirty_flag = true;
-}
-
-void Primitive::setPrimitiveData( const char* label, const helios::vec3& data ){
-  primitive_data_vec3[label] = {data};
-  primitive_data_types[label] = HELIOS_TYPE_VEC3;
-    dirty_flag = true;
-}
-
-void Primitive::setPrimitiveData( const char* label, const helios::vec4& data ){
-  primitive_data_vec4[label] = {data};
-  primitive_data_types[label] = HELIOS_TYPE_VEC4;
-    dirty_flag = true;
-}
-
-void Primitive::setPrimitiveData( const char* label, const helios::int2& data ){
-  primitive_data_int2[label] = {data};
-  primitive_data_types[label] = HELIOS_TYPE_INT2;
-    dirty_flag = true;
-}
-
-void Primitive::setPrimitiveData( const char* label, const helios::int3& data ){
-  primitive_data_int3[label] = {data};
-  primitive_data_types[label] = HELIOS_TYPE_INT3;
-    dirty_flag = true;
-}
-
-void Primitive::setPrimitiveData( const char* label, const helios::int4& data ){
-  primitive_data_int4[label] = {data};
-  primitive_data_types[label] = HELIOS_TYPE_INT4;
-    dirty_flag = true;
-}
-
-void Primitive::setPrimitiveData( const char* label, const std::string& data ){
-  primitive_data_string[label] = {data};
-  primitive_data_types[label] = HELIOS_TYPE_STRING;
-    dirty_flag = true;
-}
-
-void Primitive::setPrimitiveData( const char* label, HeliosDataType type, uint size, void* data ){
-
-    primitive_data_types[label] = type;
-
-    if( type==HELIOS_TYPE_INT ){
-        int *data_ptr = scast<int *>(data);
-
-        primitive_data_int[label].resize(size);
-        for( size_t i=0; i<size; i++ ){
-            primitive_data_int[label].at(i) = data_ptr[i];
-        }
-
-    }else if( type==HELIOS_TYPE_UINT ){
-        uint *data_ptr = scast<uint *>(data);
-
-        primitive_data_uint[label].resize(size);
-        for( size_t i=0; i<size; i++ ){
-            primitive_data_uint[label].at(i) = data_ptr[i];
-        }
-
-    }else if( type==HELIOS_TYPE_FLOAT ){
-        auto *data_ptr = scast<float *>(data);
-
-        primitive_data_float[label].resize(size);
-        for( size_t i=0; i<size; i++ ){
-            primitive_data_float[label].at(i) = data_ptr[i];
-        }
-
-    }else if( type==HELIOS_TYPE_DOUBLE ){
-        auto *data_ptr = scast<double *>(data);
-
-        primitive_data_double[label].resize(size);
-        for( size_t i=0; i<size; i++ ){
-            primitive_data_double[label].at(i) = data_ptr[i];
-        }
-
-    }else if( type==HELIOS_TYPE_VEC2 ){
-        auto *data_ptr = scast<vec2 *>(data);
-
-        primitive_data_vec2[label].resize(size);
-        for( size_t i=0; i<size; i++ ){
-            primitive_data_vec2[label].at(i) = data_ptr[i];
-        }
-
-    }else if( type==HELIOS_TYPE_VEC3 ){
-        auto *data_ptr = scast<vec3 *>(data);
-
-        primitive_data_vec3[label].resize(size);
-        for( size_t i=0; i<size; i++ ){
-            primitive_data_vec3[label].at(i) = data_ptr[i];
-        }
-
-    }else if( type==HELIOS_TYPE_VEC4 ){
-        auto *data_ptr = scast<vec4 *>(data);
-
-        primitive_data_vec4[label].resize(size);
-        for( size_t i=0; i<size; i++ ){
-            primitive_data_vec4[label].at(i) = data_ptr[i];
-        }
-
-    }else if( type==HELIOS_TYPE_INT2 ){
-        auto *data_ptr = scast<int2 *>(data);
-
-        primitive_data_int2[label].resize(size);
-        for( size_t i=0; i<size; i++ ){
-            primitive_data_int2[label].at(i) = data_ptr[i];
-        }
-
-    }else if( type==HELIOS_TYPE_INT3 ){
-        auto *data_ptr = scast<int3 *>(data);
-
-        primitive_data_int3[label].resize(size);
-        for( size_t i=0; i<size; i++ ){
-            primitive_data_int3[label].at(i) = data_ptr[i];
-        }
-
-    }else if( type==HELIOS_TYPE_INT4 ){
-        auto *data_ptr = scast<int4 *>(data);
-
-        primitive_data_int4[label].resize(size);
-        for( size_t i=0; i<size; i++ ){
-            primitive_data_int4[label].at(i) = data_ptr[i];
-        }
-
-    }else if( type==HELIOS_TYPE_STRING ){
-        auto *data_ptr = scast<std::string *>(data);
-
-        primitive_data_string[label].resize(size);
-        for( size_t i=0; i<size; i++ ){
-            primitive_data_string[label].at(i) = data_ptr[i];
-        }
-
-    }
-
-    dirty_flag = true;
-}
-
-void Primitive::getPrimitiveData( const char* label, int& data ) const{
+HeliosDataType Primitive::getPrimitiveDataType( const char* label ) const{
 
 #ifdef HELIOS_DEBUG
   if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
+    helios_runtime_error( "ERROR (Primitive::getPrimitiveDataType): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
   }
 #endif
 
-  const HeliosDataType &type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_INT ){
-    data = primitive_data_int.at(label).front();
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type int, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type int." );
-  }
+  return primitive_data_types.at(label);
 
 }
 
-void Primitive::getPrimitiveData( const char* label, std::vector<int>& data ) const{
+uint Primitive::getPrimitiveDataSize( const char* label ) const{
 
 #ifdef HELIOS_DEBUG
   if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
+    helios_runtime_error( "ERROR (Primitive::getPrimitiveDataSize): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
   }
 #endif
 
   const HeliosDataType &type = primitive_data_types.at(label);
 
   if( type==HELIOS_TYPE_INT ){
-    data = primitive_data_int.at(label);
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type int, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type int." );
-  }
-
-}
-
-void Primitive::getPrimitiveData( const char* label, uint& data ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
-  }
-#endif
-
-  const HeliosDataType &type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_UINT ){
-    data = primitive_data_uint.at(label).front();
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type uint, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type uint." );
-  }
-
-}
-
-void Primitive::getPrimitiveData( const char* label, std::vector<uint>& data ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
-  }
-#endif
-
-  const HeliosDataType &type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_UINT ){
-    data = primitive_data_uint.at(label);
+    return primitive_data_int.at(label).size();
+  }else if( type==HELIOS_TYPE_UINT ){
+    return primitive_data_uint.at(label).size();
+  }else if( type==HELIOS_TYPE_FLOAT ){
+    return primitive_data_float.at(label).size();
+  }else if( type==HELIOS_TYPE_DOUBLE ){
+    return primitive_data_double.at(label).size();
+  }else if( type==HELIOS_TYPE_VEC2 ){
+    return primitive_data_vec2.at(label).size();
+  }else if( type==HELIOS_TYPE_VEC3 ){
+    return primitive_data_vec3.at(label).size();
+  }else if( type==HELIOS_TYPE_VEC4 ){
+    return primitive_data_vec4.at(label).size();
+  }else if( type==HELIOS_TYPE_INT2 ){
+    return primitive_data_int2.at(label).size();
+  }else if( type==HELIOS_TYPE_INT3 ){
+    return primitive_data_int3.at(label).size();
+  }else if( type==HELIOS_TYPE_INT4 ){
+    return primitive_data_int4.at(label).size();
+  }else if( type==HELIOS_TYPE_STRING ){
+    return primitive_data_string.at(label).size();
   }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type uint, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type uint." );
-  }
-
-}
-
-void Primitive::getPrimitiveData( const char* label, float& data ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
+    assert( false );
   }
-#endif
-
-  const HeliosDataType &type = primitive_data_types.at(label);
 
-  if( type==HELIOS_TYPE_FLOAT ){
-    data = primitive_data_float.at(label).front();
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type float, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type float." );
-  }
+  return 0;
 
 }
 
-void Primitive::getPrimitiveData( const char* label, std::vector<float>& data ) const{
+void Primitive::clearPrimitiveData( const char* label ){
 
-#ifdef HELIOS_DEBUG
   if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
+    return;
   }
-#endif
 
-  const HeliosDataType &type = primitive_data_types.at(label);
+  HeliosDataType type = primitive_data_types.at(label);
 
-  if( type==HELIOS_TYPE_FLOAT ){
-    data = primitive_data_float.at(label);
+  if( type==HELIOS_TYPE_INT ){
+    primitive_data_int.erase(label);
+    primitive_data_types.erase(label);
+  }else if( type==HELIOS_TYPE_UINT ){
+    primitive_data_uint.erase(label);
+    primitive_data_types.erase(label);
+  }else if( type==HELIOS_TYPE_FLOAT ){
+    primitive_data_float.erase(label);
+    primitive_data_types.erase(label);
+  }else if( type==HELIOS_TYPE_DOUBLE ){
+    primitive_data_double.erase(label);
+    primitive_data_types.erase(label);
+  }else if( type==HELIOS_TYPE_VEC2 ){
+    primitive_data_vec2.erase(label);
+    primitive_data_types.erase(label);
+  }else if( type==HELIOS_TYPE_VEC3 ){
+    primitive_data_vec3.erase(label);
+    primitive_data_types.erase(label);
+  }else if( type==HELIOS_TYPE_VEC4 ){
+    primitive_data_vec4.erase(label);
+    primitive_data_types.erase(label);
+  }else if( type==HELIOS_TYPE_INT2 ){
+    primitive_data_int2.erase(label);
+    primitive_data_types.erase(label);
+  }else if( type==HELIOS_TYPE_INT3 ){
+    primitive_data_int3.erase(label);
+    primitive_data_types.erase(label);
+  }else if( type==HELIOS_TYPE_INT4 ){
+    primitive_data_int4.erase(label);
+    primitive_data_types.erase(label);
+  }else if( type==HELIOS_TYPE_STRING ){
+    primitive_data_string.erase(label);
+    primitive_data_types.erase(label);
   }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type float, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type float." );
+    assert(false);
   }
-
+    dirty_flag = true;
 }
 
-void Primitive::getPrimitiveData( const char* label, double& data ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
-  }
-#endif
-
-  const HeliosDataType &type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_DOUBLE ){
-    data = primitive_data_double.at(label).front();
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type double, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type double." );
+bool Primitive::doesPrimitiveDataExist(const char *label) const {
+  if (primitive_data_types.find(std::string(label)) == primitive_data_types.end()) {
+    return false;
   }
-
+  return true;
 }
 
-void Primitive::getPrimitiveData( const char* label, std::vector<double>& data ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
-  }
-#endif
-
-  const HeliosDataType &type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_DOUBLE ){
-    data = primitive_data_double.at(label);
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type double, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type double." );
-  }
-
-}
+std::vector<std::string> Primitive::listPrimitiveData() const{
 
-void Primitive::getPrimitiveData( const char* label, vec2& data ) const{
+  std::vector<std::string> labels(primitive_data_types.size());
 
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
+  size_t i=0;
+  for(const auto & primitive_data_type : primitive_data_types){
+    labels.at(i) = primitive_data_type.first;
+    i++;
   }
-#endif
 
-  const HeliosDataType &type = primitive_data_types.at(label);
+  return labels;
 
-  if( type==HELIOS_TYPE_VEC2 ){
-    data = primitive_data_vec2.at(label).front();
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type vec2, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type vec2." );
-  }
-
-}
-
-void Primitive::getPrimitiveData( const char* label, std::vector<vec2>& data ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
-  }
-#endif
-
-  const HeliosDataType &type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_VEC2 ){
-    data = primitive_data_vec2.at(label);
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type vec2, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type vec2." );
-  }
-
-}
-
-void Primitive::getPrimitiveData( const char* label, vec3& data ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
-  }
-#endif
-
-  const HeliosDataType &type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_VEC3 ){
-    data = primitive_data_vec3.at(label).front();
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type vec3, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type vec3." );
-  }
-
-}
-
-void Primitive::getPrimitiveData( const char* label, std::vector<vec3>& data ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
-  }
-#endif
-
-  const HeliosDataType &type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_VEC3 ){
-    data = primitive_data_vec3.at(label);
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type vec3, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type vec3." );
-  }
-
-}
-
-void Primitive::getPrimitiveData( const char* label, vec4& data ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
-  }
-#endif
-
-  const HeliosDataType &type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_VEC4 ){
-    data = primitive_data_vec4.at(label).front();
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type vec4, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type vec4." );
-  }
-
-}
-
-void Primitive::getPrimitiveData( const char* label, std::vector<vec4>& data ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
-  }
-#endif
-
-  const HeliosDataType &type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_VEC4 ){
-    data = primitive_data_vec4.at(label);
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type vec4, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type vec4." );
-  }
-
-}
-
-void Primitive::getPrimitiveData( const char* label, int2& data ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
-  }
-#endif
-
-  const HeliosDataType &type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_INT2 ){
-    data = primitive_data_int2.at(label).front();
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type int2, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type int2." );
-  }
-
-}
-
-void Primitive::getPrimitiveData( const char* label, std::vector<int2>& data ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
-  }
-#endif
-
-  const HeliosDataType &type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_INT2 ){
-    data = primitive_data_int2.at(label);
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type int2, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type int2." );
-  }
-
-}
-
-void Primitive::getPrimitiveData( const char* label, int3& data ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
-  }
-#endif
-
-  const HeliosDataType &type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_INT3 ){
-    data = primitive_data_int3.at(label).front();
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type int3, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type int3." );
-  }
-
-}
-
-void Primitive::getPrimitiveData( const char* label, std::vector<int3>& data ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
-  }
-#endif
-
-  const HeliosDataType &type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_INT3 ){
-    data = primitive_data_int3.at(label);
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type int3, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type int3." );
-  }
-
-}
-
-void Primitive::getPrimitiveData( const char* label, int4& data ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
-  }
-#endif
-
-  const HeliosDataType &type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_INT4 ){
-    data = primitive_data_int4.at(label).front();
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type int4, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type int4." );
-  }
-
-}
-
-void Primitive::getPrimitiveData( const char* label, std::vector<int4>& data ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
-  }
-#endif
-
-  const HeliosDataType &type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_INT4 ){
-    data = primitive_data_int4.at(label);
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type int4, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type int4." );
-  }
-
-}
-
-void Primitive::getPrimitiveData( const char* label, std::string& data ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
-  }
-#endif
-
-  const HeliosDataType &type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_STRING ){
-    data = primitive_data_string.at(label).front();
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type string, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type string." );
-  }
-
-}
-
-void Primitive::getPrimitiveData( const char* label, std::vector<std::string>& data ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
-  }
-#endif
-
-  const HeliosDataType &type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_STRING ){
-    data = primitive_data_string.at(label);
-  }else{
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveData): Attempted to get data for type string, but data " + std::string(label) + " for primitive " + std::to_string(UUID) + " does not have type string." );
-  }
-
-}
-
-HeliosDataType Primitive::getPrimitiveDataType( const char* label ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveDataType): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
-  }
-#endif
-
-  return primitive_data_types.at(label);
-
-}
-
-uint Primitive::getPrimitiveDataSize( const char* label ) const{
-
-#ifdef HELIOS_DEBUG
-  if( !doesPrimitiveDataExist( label ) ){
-    helios_runtime_error( "ERROR (Primitive::getPrimitiveDataSize): Primitive data " + std::string(label) + " does not exist for primitive " + std::to_string(UUID) );
-  }
-#endif
-
-  const HeliosDataType &type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_INT ){
-    return primitive_data_int.at(label).size();
-  }else if( type==HELIOS_TYPE_UINT ){
-    return primitive_data_uint.at(label).size();
-  }else if( type==HELIOS_TYPE_FLOAT ){
-    return primitive_data_float.at(label).size();
-  }else if( type==HELIOS_TYPE_DOUBLE ){
-    return primitive_data_double.at(label).size();
-  }else if( type==HELIOS_TYPE_VEC2 ){
-    return primitive_data_vec2.at(label).size();
-  }else if( type==HELIOS_TYPE_VEC3 ){
-    return primitive_data_vec3.at(label).size();
-  }else if( type==HELIOS_TYPE_VEC4 ){
-    return primitive_data_vec4.at(label).size();
-  }else if( type==HELIOS_TYPE_INT2 ){
-    return primitive_data_int2.at(label).size();
-  }else if( type==HELIOS_TYPE_INT3 ){
-    return primitive_data_int3.at(label).size();
-  }else if( type==HELIOS_TYPE_INT4 ){
-    return primitive_data_int4.at(label).size();
-  }else if( type==HELIOS_TYPE_STRING ){
-    return primitive_data_string.at(label).size();
-  }else{
-    assert( false );
-  }
-
-  return 0;
-
-}
-
-void Primitive::clearPrimitiveData( const char* label ){
-
-  if( !doesPrimitiveDataExist( label ) ){
-    return;
-  }
-
-  HeliosDataType type = primitive_data_types.at(label);
-
-  if( type==HELIOS_TYPE_INT ){
-    primitive_data_int.erase(label);
-    primitive_data_types.erase(label);
-  }else if( type==HELIOS_TYPE_UINT ){
-    primitive_data_uint.erase(label);
-    primitive_data_types.erase(label);
-  }else if( type==HELIOS_TYPE_FLOAT ){
-    primitive_data_float.erase(label);
-    primitive_data_types.erase(label);
-  }else if( type==HELIOS_TYPE_DOUBLE ){
-    primitive_data_double.erase(label);
-    primitive_data_types.erase(label);
-  }else if( type==HELIOS_TYPE_VEC2 ){
-    primitive_data_vec2.erase(label);
-    primitive_data_types.erase(label);
-  }else if( type==HELIOS_TYPE_VEC3 ){
-    primitive_data_vec3.erase(label);
-    primitive_data_types.erase(label);
-  }else if( type==HELIOS_TYPE_VEC4 ){
-    primitive_data_vec4.erase(label);
-    primitive_data_types.erase(label);
-  }else if( type==HELIOS_TYPE_INT2 ){
-    primitive_data_int2.erase(label);
-    primitive_data_types.erase(label);
-  }else if( type==HELIOS_TYPE_INT3 ){
-    primitive_data_int3.erase(label);
-    primitive_data_types.erase(label);
-  }else if( type==HELIOS_TYPE_INT4 ){
-    primitive_data_int4.erase(label);
-    primitive_data_types.erase(label);
-  }else if( type==HELIOS_TYPE_STRING ){
-    primitive_data_string.erase(label);
-    primitive_data_types.erase(label);
-  }else{
-    assert(false);
-  }
-    dirty_flag = true;
-}
-
-bool Primitive::doesPrimitiveDataExist(const char *label) const {
-  if (primitive_data_types.find(std::string(label)) == primitive_data_types.end()) {
-    return false;
-  }
-  return true;
-}
-
-std::vector<std::string> Primitive::listPrimitiveData() const{
-
-  std::vector<std::string> labels(primitive_data_types.size());
-
-  size_t i=0;
-  for(const auto & primitive_data_type : primitive_data_types){
-    labels.at(i) = primitive_data_type.first;
-    i++;
-  }
-
-  return labels;
-
-}
-
-void Context::setPrimitiveData(uint UUID, const char* label, int data){
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->setPrimitiveData(label,data);
-}
-
-void Context::setPrimitiveData( const std::vector<uint> &UUIDs, const char* label, const std::vector<int> &data ) {
-#ifdef HELIOS_DEBUG
-  if( UUIDs.size() != data.size() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUIDs and data vectors must be the same size.");
-  }
-#endif
-
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for ( uint p=0; p<UUIDs.size(); p++ ){
-    primitives.at(UUIDs.at(p))->setPrimitiveData(label, data.at(p));
-  }
-}
-
-void Context::setPrimitiveData(uint UUID, const char* label, uint data){
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->setPrimitiveData(label,data);
-}
-
-void Context::setPrimitiveData( const std::vector<uint> &UUIDs, const char* label, const std::vector<uint> &data ) {
-#ifdef HELIOS_DEBUG
-  if( UUIDs.size() != data.size() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUIDs and data vectors must be the same size.");
-  }
-#endif
-
-#ifdef USE_OPENMP
-#pragma omp parallel for
-#endif
-  for ( uint p=0; p<UUIDs.size(); p++ ){
-    primitives.at(UUIDs.at(p))->setPrimitiveData(label, data.at(p));
-  }
-}
-
-void Context::setPrimitiveData(uint UUID, const char* label, float data){
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->setPrimitiveData(label,data);
-}
-
-void Context::setPrimitiveData( const std::vector<uint> &UUIDs, const char* label, const std::vector<float> &data ) {
-#ifdef HELIOS_DEBUG
-  if( UUIDs.size() != data.size() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUIDs and data vectors must be the same size.");
-  }
-#endif
-
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for ( uint p=0; p<UUIDs.size(); p++ ){
-    primitives.at(UUIDs.at(p))->setPrimitiveData(label, data.at(p));
-  }
-}
-
-void Context::setPrimitiveData(uint UUID, const char* label, double data){
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->setPrimitiveData(label,data);
-}
-
-void Context::setPrimitiveData( const std::vector<uint> &UUIDs, const char* label, const std::vector<double> &data ) {
-#ifdef HELIOS_DEBUG
-  if( UUIDs.size() != data.size() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUIDs and data vectors must be the same size.");
-  }
-#endif
-
-#ifdef USE_OPENMP
-#pragma omp parallel for
-#endif
-  for ( uint p=0; p<UUIDs.size(); p++ ){
-    primitives.at(UUIDs.at(p))->setPrimitiveData(label, data.at(p));
-  }
-}
-
-void Context::setPrimitiveData( uint UUID, const char* label, const helios::vec2& data ){
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->setPrimitiveData(label,data);
-}
-
-void Context::setPrimitiveData( const std::vector<uint> &UUIDs, const char* label, const std::vector<vec2> &data ) {
-#ifdef HELIOS_DEBUG
-  if( UUIDs.size() != data.size() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUIDs and data vectors must be the same size.");
-  }
-#endif
-
-#ifdef USE_OPENMP
-#pragma omp parallel for
-#endif
-  for ( uint p=0; p<UUIDs.size(); p++ ){
-    primitives.at(UUIDs.at(p))->setPrimitiveData(label, data.at(p));
-  }
-}
-
-void Context::setPrimitiveData( uint UUID, const char* label, const helios::vec3& data ){
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->setPrimitiveData(label,data);
-}
-
-void Context::setPrimitiveData( const std::vector<uint> &UUIDs, const char* label, const std::vector<vec3> &data ) {
-#ifdef HELIOS_DEBUG
-  if( UUIDs.size() != data.size() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUIDs and data vectors must be the same size.");
-  }
-#endif
-
-#ifdef USE_OPENMP
-#pragma omp parallel for
-#endif
-  for ( uint p=0; p<UUIDs.size(); p++ ){
-    primitives.at(UUIDs.at(p))->setPrimitiveData(label, data.at(p));
-  }
-}
-
-void Context::setPrimitiveData( uint UUID, const char* label, const helios::vec4& data ){
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->setPrimitiveData(label,data);
-}
-
-void Context::setPrimitiveData( const std::vector<uint> &UUIDs, const char* label, const std::vector<vec4> &data ) {
-#ifdef HELIOS_DEBUG
-  if( UUIDs.size() != data.size() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUIDs and data vectors must be the same size.");
-  }
-#endif
-
-#ifdef USE_OPENMP
-#pragma omp parallel for
-#endif
-  for ( uint p=0; p<UUIDs.size(); p++ ){
-    primitives.at(UUIDs.at(p))->setPrimitiveData(label, data.at(p));
-  }
-}
-
-void Context::setPrimitiveData( uint UUID, const char* label, const helios::int2& data ){
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->setPrimitiveData(label,data);
-}
-
-void Context::setPrimitiveData( const std::vector<uint> &UUIDs, const char* label, const std::vector<int2> &data ) {
-#ifdef HELIOS_DEBUG
-  if( UUIDs.size() != data.size() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUIDs and data vectors must be the same size.");
-  }
-#endif
-
-#ifdef USE_OPENMP
-#pragma omp parallel for
-#endif
-  for ( uint p=0; p<UUIDs.size(); p++ ){
-    primitives.at(UUIDs.at(p))->setPrimitiveData(label, data.at(p));
-  }
-}
-
-void Context::setPrimitiveData( uint UUID, const char* label, const helios::int3& data ){
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->setPrimitiveData(label,data);
-}
-
-void Context::setPrimitiveData( const std::vector<uint> &UUIDs, const char* label, const std::vector<int3> &data ) {
-#ifdef HELIOS_DEBUG
-  if( UUIDs.size() != data.size() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUIDs and data vectors must be the same size.");
-  }
-#endif
-
-#ifdef USE_OPENMP
-#pragma omp parallel for
-#endif
-  for ( uint p=0; p<UUIDs.size(); p++ ){
-    primitives.at(UUIDs.at(p))->setPrimitiveData(label, data.at(p));
-  }
-}
-
-void Context::setPrimitiveData( uint UUID, const char* label, const helios::int4& data ){
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->setPrimitiveData(label,data);
-}
-
-void Context::setPrimitiveData( const std::vector<uint> &UUIDs, const char* label, const std::vector<int4> &data ) {
-#ifdef HELIOS_DEBUG
-  if( UUIDs.size() != data.size() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUIDs and data vectors must be the same size.");
-  }
-#endif
-
-#ifdef USE_OPENMP
-#pragma omp parallel for
-#endif
-  for ( uint p=0; p<UUIDs.size(); p++ ){
-    primitives.at(UUIDs.at(p))->setPrimitiveData(label, data.at(p));
-  }
-}
-
-void Context::setPrimitiveData( uint UUID, const char* label, const std::string& data ){
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->setPrimitiveData(label,data);
-}
-
-void Context::setPrimitiveData( const std::vector<uint> &UUIDs, const char* label, const std::vector<std::string> &data ) {
-#ifdef HELIOS_DEBUG
-  if( UUIDs.size() != data.size() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUIDs and data vectors must be the same size.");
-  }
-#endif
-
-#ifdef USE_OPENMP
-#pragma omp parallel for
-#endif
-  for ( uint p=0; p<UUIDs.size(); p++ ){
-    primitives.at(UUIDs.at(p))->setPrimitiveData(label, data.at(p));
-  }
-}
-
-void Context::setPrimitiveData( uint UUID, const char* label, HeliosDataType type, uint size, void* data ){
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error( "ERROR (Context::setPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->setPrimitiveData(label,type,size,data);
-}
-
-void Context::setPrimitiveData( const std::vector<uint>& UUIDs, const char* label, const int& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for( uint UUID : UUIDs){
-    primitives.at(UUID)->setPrimitiveData(label,data);
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<uint>& UUIDs, const char* label, const uint& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for( uint UUID : UUIDs){
-    primitives.at(UUID)->setPrimitiveData(label,data);
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<uint>& UUIDs, const char* label, const float& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for( uint UUID : UUIDs){
-    primitives.at(UUID)->setPrimitiveData(label,data);
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<uint>& UUIDs, const char* label, const double& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for( uint UUID : UUIDs){
-    primitives.at(UUID)->setPrimitiveData(label,data);
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<uint>& UUIDs, const char* label, const helios::vec2& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for( uint UUID : UUIDs){
-    primitives.at(UUID)->setPrimitiveData(label,data);
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<uint>& UUIDs, const char* label, const helios::vec3& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for( uint UUID : UUIDs){
-    primitives.at(UUID)->setPrimitiveData(label,data);
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<uint>& UUIDs, const char* label, const helios::vec4& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for( uint UUID : UUIDs){
-    primitives.at(UUID)->setPrimitiveData(label,data);
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<uint>& UUIDs, const char* label, const helios::int2& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for( uint UUID : UUIDs){
-    primitives.at(UUID)->setPrimitiveData(label,data);
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<uint>& UUIDs, const char* label, const helios::int3& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for( uint UUID : UUIDs){
-    primitives.at(UUID)->setPrimitiveData(label,data);
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<uint>& UUIDs, const char* label, const helios::int4& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for( uint UUID : UUIDs){
-    primitives.at(UUID)->setPrimitiveData(label,data);
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<uint>& UUIDs, const char* label, const std::string& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for( uint UUID : UUIDs){
-    primitives.at(UUID)->setPrimitiveData(label,data);
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<uint> >& UUIDs, const char* label, const int& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& UUID : j ){
-      primitives.at(UUID)->setPrimitiveData(label,data);
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<uint> >& UUIDs, const char* label, const uint& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& UUID : j ){
-      primitives.at(UUID)->setPrimitiveData(label,data);
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<uint> >& UUIDs, const char* label, const float& data ){
-#ifdef USE_OPENMP
-#pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& UUID : j ){
-      primitives.at(UUID)->setPrimitiveData(label,data);
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<uint> >& UUIDs, const char* label, const double& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& UUID : j ){
-      primitives.at(UUID)->setPrimitiveData(label,data);
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<uint> >& UUIDs, const char* label, const helios::vec2& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& UUID : j ){
-      primitives.at(UUID)->setPrimitiveData(label,data);
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<uint> >& UUIDs, const char* label, const helios::vec3& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& UUID : j ){
-      primitives.at(UUID)->setPrimitiveData(label,data);
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<uint> >& UUIDs, const char* label, const helios::vec4& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& UUID : j ){
-      primitives.at(UUID)->setPrimitiveData(label,data);
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<uint> >& UUIDs, const char* label, const helios::int2& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& UUID : j ){
-      primitives.at(UUID)->setPrimitiveData(label,data);
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<uint> >& UUIDs, const char* label, const helios::int3& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& UUID : j ){
-      primitives.at(UUID)->setPrimitiveData(label,data);
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<uint> >& UUIDs, const char* label, const helios::int4& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& UUID : j ){
-      primitives.at(UUID)->setPrimitiveData(label,data);
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<uint> >& UUIDs, const char* label, const std::string& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& UUID : j ){
-      primitives.at(UUID)->setPrimitiveData(label,data);
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<std::vector<uint> > >& UUIDs, const char* label, const int& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& i : j ) {
-      for (const auto &UUID: i) {
-        primitives.at(UUID)->setPrimitiveData(label,data);
-      }
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<std::vector<uint> > >& UUIDs, const char* label, const uint& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& i : j ) {
-      for (const auto &UUID: i) {
-        primitives.at(UUID)->setPrimitiveData(label,data);
-      }
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<std::vector<uint> > >& UUIDs, const char* label, const float& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& i : j ) {
-      for (const auto &UUID: i) {
-        primitives.at(UUID)->setPrimitiveData(label,data);
-      }
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<std::vector<uint> > >& UUIDs, const char* label, const double& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& i : j ) {
-      for (const auto &UUID: i) {
-        primitives.at(UUID)->setPrimitiveData(label,data);
-      }
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<std::vector<uint> > >& UUIDs, const char* label, const helios::vec2& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& i : j ) {
-      for (const auto &UUID: i) {
-        primitives.at(UUID)->setPrimitiveData(label,data);
-      }
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<std::vector<uint> > >& UUIDs, const char* label, const helios::vec3& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& i : j ) {
-      for (const auto &UUID: i) {
-        primitives.at(UUID)->setPrimitiveData(label,data);
-      }
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<std::vector<uint> > >& UUIDs, const char* label, const helios::vec4& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& i : j ) {
-      for (const auto &UUID: i) {
-        primitives.at(UUID)->setPrimitiveData(label,data);
-      }
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<std::vector<uint> > >& UUIDs, const char* label, const helios::int2& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& i : j ) {
-      for (const auto &UUID: i) {
-        primitives.at(UUID)->setPrimitiveData(label,data);
-      }
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<std::vector<uint> > >& UUIDs, const char* label, const helios::int3& data ){
-  for(const auto & j : UUIDs){
-    for( const auto& i : j ) {
-      for (const auto &UUID: i) {
-        primitives.at(UUID)->setPrimitiveData(label,data);
-      }
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<std::vector<uint> > >& UUIDs, const char* label, const helios::int4& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& i : j ) {
-      for (const auto &UUID: i) {
-        primitives.at(UUID)->setPrimitiveData(label,data);
-      }
-    }
-  }
-}
-
-void Context::setPrimitiveData( const std::vector<std::vector<std::vector<uint> > >& UUIDs, const char* label, const std::string& data ){
-#ifdef USE_OPENMP
-  #pragma omp parallel for
-#endif
-  for(const auto & j : UUIDs){
-    for( const auto& i : j ) {
-      for (const auto &UUID: i) {
-        primitives.at(UUID)->setPrimitiveData(label,data);
-      }
-    }
-  }
-}
-
-void Context::getPrimitiveData(uint UUID, const char* label, int& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, std::vector<int>& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, uint& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, std::vector<uint>& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, float& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, std::vector<float>& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, double& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, std::vector<double>& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, vec2& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, std::vector<vec2>& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, vec3& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, std::vector<vec3>& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, vec4& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, std::vector<vec4>& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, int2& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, std::vector<int2>& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, int3& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, std::vector<int3>& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, int4& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, std::vector<int4>& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, std::string& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
-}
-
-void Context::getPrimitiveData( uint UUID, const char* label, std::vector<std::string>& data ) const{
-#ifdef HELIOS_DEBUG
-  if( primitives.find(UUID) == primitives.end() ){
-    helios_runtime_error("ERROR (Context::getPrimitiveData): UUID of " + std::to_string(UUID) + " does not exist in the Context.");
-  }
-#endif
-  primitives.at(UUID)->getPrimitiveData(label,data);
 }
 
 HeliosDataType Context::getPrimitiveDataType( uint UUID, const char* label )const{