temp

source/gameengine/Converter/BL_BlenderDataConversion.cpp

@@ -515,10 +515,8 @@ KX_Mesh *BL_ConvertMesh(Mesh *me, Object *blenderobj, KX_Scene *scene, BL_SceneC
 		RAS_MaterialBucket *bucket = BL_ConvertMaterial(ma, scene, converter);
 		RAS_MeshMaterial *meshmat = meshobj->AddMaterial(bucket, i, vertformat);
 		RAS_IMaterial *mat = meshmat->GetBucket()->GetMaterial();
-		RAS_IVertexFactory *factory = RAS_IVertexFactory::Construct(vertformat);
 
-		mats[i] = BL_MeshMaterial(meshmat->GetDisplayArray(), factory, bucket,
-				mat->IsVisible(), mat->IsTwoSided(), mat->IsCollider(), mat->IsWire());
+		mats[i] = {meshmat->GetDisplayArray(), bucket, mat->IsVisible(), mat->IsTwoSided(), mat->IsCollider(), mat->IsWire()};
 	}
 
 	BL_ConvertDerivedMeshToArray(dm, me, mats, layersInfo);
@@ -582,7 +580,6 @@ void BL_ConvertDerivedMeshToArray(DerivedMesh *dm, Mesh *me, const std::vector<B
 
 		const BL_MeshMaterial& mat = mats[mpoly.mat_nr];
 		RAS_DisplayArray *array = mat.array;
-		RAS_IVertexFactory *factory = mat.vertexFactory.get();
 
 		// Mark face as flat, so vertices are split.
 		const bool flat = (mpoly.flag & ME_SMOOTH) == 0;

source/gameengine/Converter/BL_BlenderDataConversion.h

@@ -38,7 +38,6 @@
 
 class RAS_Rasterizer;
 class RAS_ICanvas;
-class RAS_IVertexFactory;
 class KX_KetsjiEngine;
 class KX_Scene;
 class BL_SceneConverter;

source/gameengine/Converter/BL_ModifierDeformer.cpp

@@ -42,7 +42,6 @@
 #include "RAS_Mesh.h"
 #include "RAS_MeshUser.h"
 #include "RAS_BoundingBox.h"
-#include "RAS_VertexFactory.h"
 
 #include "DNA_armature_types.h"
 #include "DNA_action_types.h"
@@ -178,10 +177,7 @@ void BL_ModifierDeformer::UpdateTransverts()
 		array->Clear();
 
 		RAS_IMaterial *mat = meshmat->GetBucket()->GetMaterial();
-		RAS_IVertexFactory *factory = RAS_IVertexFactory::Construct(array->GetFormat());
-
-		mats[i] = BL_MeshMaterial(array, factory, meshmat->GetBucket(),
-				mat->IsVisible(), mat->IsTwoSided(), mat->IsCollider(), mat->IsWire());
+		mats[i] = {array, meshmat->GetBucket(), mat->IsVisible(), mat->IsTwoSided(), mat->IsCollider(), mat->IsWire()};
 	}
 
 	BL_ConvertDerivedMeshToArray(m_dm, m_bmesh, mats, m_mesh->GetLayersInfo());

source/gameengine/Ketsji/KX_MeshBuilder.cpp

@@ -23,27 +23,19 @@ KX_MeshBuilderSlot::KX_MeshBuilderSlot(KX_BlenderMaterial *material, RAS_Display
 {
 }
 
-KX_MeshBuilderSlot::KX_MeshBuilderSlot(RAS_MeshMaterial *meshmat, const RAS_VertexFormat& format, unsigned int& origIndexCounter)
-	:m_format(format),
-	m_factory(RAS_IVertexFactory::Construct(m_format)),
-	m_origIndexCounter(origIndexCounter)
+KX_MeshBuilderSlot::KX_MeshBuilderSlot(RAS_MeshMaterial *meshmat, const RAS_DisplayArray::Format& format,
+		unsigned int& origIndexCounter)
+	:m_origIndexCounter(origIndexCounter)
 {
 	RAS_MaterialBucket *bucket = meshmat->GetBucket();
-	m_material = static_cast<KX_BlenderMaterial *>(bucket->GetPolyMaterial());
-
-	RAS_IDisplayArray *array = meshmat->GetDisplayArray();
-	m_primitive = array->GetPrimitiveType();
+	m_material = static_cast<KX_BlenderMaterial *>(bucket->GetMaterial());
 
-	m_vertexInfos = array->GetVertexInfoList();
-	m_primitiveIndices = array->GetPrimitiveIndexList();
-	m_triangleIndices = array->GetTriangleIndexList();
-
-	for (unsigned int i = 0, size = array->GetVertexCount(); i < size; ++i) {
-		m_vertices.push_back(m_factory->CopyVertex(array->GetVertexData(i)));
-	}
+	RAS_DisplayArray *array = meshmat->GetDisplayArray();
+	BLI_assert(array->GetType() == RAS_DisplayArray::NORMAL);
+	m_array = new RAS_DisplayArray(*array);
 
 	// Compute the maximum original index from the arrays.
-	m_origIndexCounter = std::max(m_origIndexCounter, array->GetMaxOrigIndex());
+	m_origIndexCounter = std::max(m_origIndexCounter, m_array->GetMaxOrigIndex());
 }
 
 KX_MeshBuilderSlot::~KX_MeshBuilderSlot()
@@ -226,19 +218,19 @@ PyObject *KX_MeshBuilderSlot::PyAddVertex(PyObject *args, PyObject *kwds)
 		return nullptr;
 	}
 
-	mt::vec3_packed normal = mt::axisZ3;
+	mt::vec3_packed normal = mt::vec3_packed(mt::axisZ3);
 	if (pynormal && !PyVecTo(pynormal, normal)) {
 		return nullptr;
 	}
 
-	mt::vec4_packed tangent = mt::one4;
+	mt::vec4_packed tangent = mt::vec4_packed(mt::one4);
 	if (pytangent && !PyVecTo(pytangent, tangent)) {
 		return nullptr;
 	}
 
 	const RAS_DisplayArray::Format& format = m_array->GetFormat();
 
-	mt::vec2_packed uvs[RAS_Texture::MaxUnits] = {mt::zero2};
+	mt::vec2_packed uvs[RAS_Texture::MaxUnits] = {mt::vec2_packed(mt::zero2)};
 	if (pyuvs) {
 		if (!PySequence_Check(pyuvs)) {
 			return nullptr;
@@ -268,8 +260,7 @@ PyObject *KX_MeshBuilderSlot::PyAddVertex(PyObject *args, PyObject *kwds)
 		}
 	}
 
-	const unsigned index = m_array->AddVertex(pos, normal, tangent, uvs, colors);
-	m_vertexInfos.emplace_back(m_origIndexCounter++, false);
+	const unsigned index = m_array->AddVertex(pos, normal, tangent, uvs, colors, m_origIndexCounter++, 0);
 
 	return PyLong_FromLong(index);
 }
@@ -281,7 +272,7 @@ PyObject *KX_MeshBuilderSlot::PyAddIndex(PyObject *value)
 		return nullptr;
 	}
 
-	const bool isTriangle = (m_primitive == RAS_DisplayArray::TRIANGLES);
+	const bool isTriangle = (m_array->GetPrimitiveType() == RAS_DisplayArray::TRIANGLES);
 
 	for (unsigned int i = 0, size = PySequence_Size(value); i < size; ++i) {
 		const int val = PyLong_AsLong(PySequence_GetItem(value, i));
@@ -291,9 +282,9 @@ PyObject *KX_MeshBuilderSlot::PyAddIndex(PyObject *value)
 			return nullptr;
 		}
 
-		m_primitiveIndices.push_back(val);
+		m_array->AddPrimitiveIndex(val);
 		if (isTriangle) {
-			m_triangleIndices.push_back(val);
+			m_array->AddTriangleIndex(val);
 		}
 	}
 
@@ -315,7 +306,7 @@ PyObject *KX_MeshBuilderSlot::PyAddPrimitiveIndex(PyObject *value)
 			return nullptr;
 		}
 
-		m_primitiveIndices.push_back(val);
+		m_array->AddPrimitiveIndex(val);
 	}
 
 	Py_RETURN_NONE;
@@ -336,29 +327,20 @@ PyObject *KX_MeshBuilderSlot::PyAddTriangleIndex(PyObject *value)
 			return nullptr;
 		}
 
-		m_triangleIndices.push_back(val);
+		m_array->AddTriangleIndex(val);
 	}
 
 	Py_RETURN_NONE;
 }
 
-template <class ListType>
-static PyObject *removeDataCheck(ListType& list, int start, int end, const std::string& errmsg)
+static bool removeDataCheck(int start, int end, unsigned int size, const std::string& errmsg)
 {
-	const int size = list.size();
-	if (start >= size || (end != -1 && (end > size || end < start))) {
-		PyErr_Format(PyExc_TypeError, "%s: range invalid, must be included in [0, %i[", errmsg.c_str(), size);
-		return nullptr;
-	}
-
-	if (end == -1) {
-		list.erase(list.begin() + start);
-	}
-	else {
-		list.erase(list.begin() + start, list.begin() + end);
+	if (start < 0 || start >= size || (end != -1 && (end > size || end <= start))) {
+		PyErr_Format(PyExc_TypeError, "%s: range invalid or empty, must be included in [0, %i[", errmsg.c_str(), size);
+		return false;
 	}
 
-	Py_RETURN_NONE;
+	return true;
 }
 
 PyObject *KX_MeshBuilderSlot::PyRemoveVertex(PyObject *args)
@@ -370,7 +352,13 @@ PyObject *KX_MeshBuilderSlot::PyRemoveVertex(PyObject *args)
 		return nullptr;
 	}
 
-	return removeDataCheck(m_vertices, start, end, "slot.removeVertex(start, end)");
+	if (!removeDataCheck(start, end, m_array->GetVertexCount(), "slot.removeVertex(start, end)")) {
+		return nullptr;
+	}
+
+	m_array->RemoveVertex(start, end);
+
+	Py_RETURN_NONE;
 }
 
 PyObject *KX_MeshBuilderSlot::PyRemovePrimitiveIndex(PyObject *args)
@@ -382,7 +370,13 @@ PyObject *KX_MeshBuilderSlot::PyRemovePrimitiveIndex(PyObject *args)
 		return nullptr;
 	}
 
-	return removeDataCheck(m_vertices, start, end, "slot.removePrimitiveIndex(start, end)");
+	if (!removeDataCheck(start, end, m_array->GetPrimitiveIndexCount(), "slot.removePrimitiveIndex(start, end)")) {
+		return nullptr;
+	}
+
+	m_array->RemovePrimitiveIndex(start, end);
+
+	Py_RETURN_NONE;
 }
 
 PyObject *KX_MeshBuilderSlot::PyRemoveTriangleIndex(PyObject *args)
@@ -394,7 +388,13 @@ PyObject *KX_MeshBuilderSlot::PyRemoveTriangleIndex(PyObject *args)
 		return nullptr;
 	}
 
-	return removeDataCheck(m_vertices, start, end, "slot.removeTriangleIndex(start, end)");
+	if (!removeDataCheck(start, end, m_array->GetTriangleIndexCount(), "slot.removeTriangleIndex(start, end)")) {
+		return nullptr;
+	}
+
+	m_array->RemoveTriangleIndex(start, end);
+
+	Py_RETURN_NONE;
 }
 
 PyObject *KX_MeshBuilderSlot::PyRecalculateNormals()
@@ -404,31 +404,30 @@ PyObject *KX_MeshBuilderSlot::PyRecalculateNormals()
 		return nullptr;
 	}
 
-	for (RAS_IVertexData *data : m_vertices) {
-		zero_v3(data->normal);
-	}
+	std::vector<mt::vec3, mt::simd_allocator<mt::vec3> > normals(m_array->GetVertexCount(), mt::zero3);
 
-	for (unsigned int i = 0, size = m_primitiveIndices.size(); i < size; i += 3) {
+	for (unsigned int i = 0, size = m_array->GetPrimitiveIndexCount(); i < size; i += 3) {
 		float normal[3];
 		normal_tri_v3(normal,
-				m_vertices[m_primitiveIndices[i]]->position,
-				m_vertices[m_primitiveIndices[i + 1]]->position,
-				m_vertices[m_primitiveIndices[i + 2]]->position);
+				m_array->GetPosition(m_array->GetPrimitiveIndex(i)).data,
+				m_array->GetPosition(m_array->GetPrimitiveIndex(i + 1)).data,
+				m_array->GetPosition(m_array->GetPrimitiveIndex(i + 2)).data);
 
+		const mt::vec3 vnormal(normal);
 		for (unsigned short j = 0; j < 3; ++j) {
-			add_v3_v3(m_vertices[m_primitiveIndices[i + j]]->normal, normal);
+			normals[m_array->GetPrimitiveIndex(i + j)] += vnormal;
 		}
 	}
 
-	for (RAS_IVertexData *data : m_vertices) {
-		normalize_v3(data->normal);
+	for (unsigned int i = 0, size = normals.size(); i < size; ++i) {
+		m_array->SetNormal(i, normals[i].SafeNormalized(mt::zero3));
 	}
 
 	Py_RETURN_NONE;
 }
 
 KX_MeshBuilder::KX_MeshBuilder(const std::string& name, KX_Scene *scene, const RAS_Mesh::LayersInfo& layersInfo,
-		const RAS_VertexFormat& format)
+		const RAS_DisplayArray::Format& format)
 	:m_name(name),
 	m_layersInfo(layersInfo),
 	m_format(format),
@@ -520,7 +519,7 @@ static PyObject *py_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 		return nullptr;
 	}
 
-	RAS_VertexFormat format{(uint8_t)max_ii(layersInfo.uvLayers.size(), 1), (uint8_t)max_ii(layersInfo.colorLayers.size(), 1)};
+	RAS_DisplayArray::Format format{(uint8_t)max_ii(layersInfo.uvLayers.size(), 1), (uint8_t)max_ii(layersInfo.colorLayers.size(), 1)};
 
 	KX_MeshBuilder *builder = new KX_MeshBuilder(name, scene, layersInfo, format);
 

source/gameengine/Ketsji/KX_MeshBuilder.h

@@ -26,7 +26,7 @@ class KX_MeshBuilderSlot : public EXP_Value
 public:
 	KX_MeshBuilderSlot(KX_BlenderMaterial *material, RAS_DisplayArray::PrimitiveType primitiveType,
 			const RAS_DisplayArray::Format& format, unsigned int& origIndexCounter);
-	KX_MeshBuilderSlot(RAS_MeshMaterial *meshmat, const RAS_VertexFormat& format, unsigned int& origIndexCounter);
+	KX_MeshBuilderSlot(RAS_MeshMaterial *meshmat, const RAS_DisplayArray::Format& format, unsigned int& origIndexCounter);
 	~KX_MeshBuilderSlot();
 
 	virtual std::string GetName();

source/gameengine/Rasterizer/RAS_DisplayArray.cpp

@@ -77,22 +77,6 @@ RAS_DisplayArray::~RAS_DisplayArray()
 {
 }
 
-RAS_IDisplayArray::RAS_IDisplayArray(PrimitiveType type, const RAS_VertexFormat& format,
-		const RAS_VertexDataMemoryFormat& memoryFormat, const VertexInfoList& vertexInfos,
-		const IndexList& primitiveIndices, const IndexList& triangleIndices)
-	:m_type(type),
-	m_format(format),
-	m_memoryFormat(memoryFormat),
-	m_vertexInfos(vertexInfos),
-	m_primitiveIndices(primitiveIndices),
-	m_triangleIndices(triangleIndices),
-	m_maxOrigIndex(0)
-{
-	for (const RAS_VertexInfo& info : m_vertexInfos) {
-		m_maxOrigIndex = std::max(m_maxOrigIndex, info.GetOrigIndex());
-	}
-}
-
 unsigned int RAS_DisplayArray::AddVertex(const mt::vec3_packed& pos, const mt::vec3_packed& nor, const mt::vec4_packed& tan,
 			mt::vec2_packed uvs[RAS_Texture::MaxUnits], unsigned int colors[RAS_Texture::MaxUnits], unsigned int origIndex, uint8_t flag)
 {
@@ -114,6 +98,44 @@ unsigned int RAS_DisplayArray::AddVertex(const mt::vec3_packed& pos, const mt::v
 	return m_vertexInfos.size() - 1;
 }
 
+template <class List>
+void removeRange(List& list, unsigned int start, unsigned int end)
+{
+	if (end == -1) {
+		list.erase(list.begin() + start);
+	}
+	else {
+		list.erase(list.begin() + start, list.begin() + end);
+	}
+}
+
+void RAS_DisplayArray::RemoveVertex(unsigned int start, unsigned int end)
+{
+	removeRange(m_vertexData.positions, start, end);
+	removeRange(m_vertexData.normals, start, end);
+	removeRange(m_vertexData.tangents, start, end);
+
+	for (unsigned short i = 0; i < m_format.uvSize; ++i) {
+		removeRange(m_vertexData.uvs[i], start, end);
+	}
+
+	for (unsigned short i = 0; i < m_format.colorSize; ++i) {
+		removeRange(m_vertexData.colors[i], start, end);
+	}
+
+	removeRange(m_vertexInfos, start, end);
+}
+
+void RAS_DisplayArray::RemovePrimitiveIndex(unsigned int start, unsigned int end)
+{
+	removeRange(m_primitiveIndices, start, end);
+}
+
+void RAS_DisplayArray::RemoveTriangleIndex(unsigned int start, unsigned int end)
+{
+	removeRange(m_triangleIndices, start, end);
+}
+
 void RAS_DisplayArray::Clear()
 {
 	m_vertexData.positions.clear();
@@ -134,14 +156,6 @@ void RAS_DisplayArray::Clear()
 	m_maxOrigIndex = 0;
 }
 
-RAS_IDisplayArray *RAS_IDisplayArray::Construct(RAS_IDisplayArray::PrimitiveType type, const RAS_VertexFormat &format,
-		const IVertexDataList& vertices, const VertexInfoList& vertexInfos,
-		const IndexList& primitiveIndices, const IndexList& triangleIndices)
-{
-	return CM_InstantiateTemplateSwitch<RAS_IDisplayArray, RAS_DisplayArray, RAS_VertexFormatTuple>(format,
-			type, format, vertices, vertexInfos, primitiveIndices, triangleIndices);
-}
-
 void RAS_DisplayArray::SortPolygons(const mt::mat3x4& transform, unsigned int *indexmap)
 {
 	const unsigned int totpoly = GetPrimitiveIndexCount() / 3;

source/gameengine/Rasterizer/RAS_DisplayArray.h

@@ -264,6 +264,10 @@ class RAS_DisplayArray : public CM_UpdateServer<RAS_DisplayArray>
 		m_triangleIndices.push_back(origIndex);
 	}
 
+	void RemoveVertex(unsigned int start, unsigned int end);
+	void RemovePrimitiveIndex(unsigned int start, unsigned int end);
+	void RemoveTriangleIndex(unsigned int start, unsigned int end);
+
 	void Clear();
 
 	inline unsigned int GetVertexCount() const

source/gameengine/Rasterizer/RAS_Mesh.cpp

@@ -195,7 +195,7 @@ RAS_MeshMaterial *RAS_Mesh::AddMaterial(RAS_MaterialBucket *bucket, unsigned int
 	return meshmat;
 }
 
-RAS_MeshMaterial *RAS_Mesh::AddMaterial(RAS_MaterialBucket *bucket, unsigned int index, RAS_IDisplayArray *array)
+RAS_MeshMaterial *RAS_Mesh::AddMaterial(RAS_MaterialBucket *bucket, unsigned int index, RAS_DisplayArray *array)
 {
 	RAS_MeshMaterial *meshmat = GetMeshMaterialBlenderIndex(index);