Added the Solid 3.5 sources to the blender source tree.

This is a direct copy from the CD-ROM contents except for the generated libraries for the Windows platform. If needed, I can add those later on. (Those take up over 800 kb). All files, including license files, documentation, examples and sources are committed.
2003-12-06 19:02:42 +00:00
parent bef272a5d2
commit 581c0f232c
96 changed files with 19374 additions and 0 deletions
--- a/extern/solid/src/DT_RespTable.cpp
+++ b/extern/solid/src/DT_RespTable.cpp
@@ -0,0 +1,184 @@
+/*
+ * SOLID - Software Library for Interference Detection
+ * 
+ * Copyright (C) 2001-2003  Dtecta.  All rights reserved.
+ *
+ * This library may be distributed under the terms of the Q Public License
+ * (QPL) as defined by Trolltech AS of Norway and appearing in the file
+ * LICENSE.QPL included in the packaging of this file.
+ *
+ * This library may be distributed and/or modified under the terms of the
+ * GNU General Public License (GPL) version 2 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.
+ *
+ * This library is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * Commercial use or any other use of this library not covered by either 
+ * the QPL or the GPL requires an additional license from Dtecta. 
+ * Please contact info@dtecta.com for enquiries about the terms of commercial
+ * use of this library.
+ */
+
+#include "DT_RespTable.h"
+
+#include <assert.h>
+
+DT_ResponseList DT_RespTable::g_emptyResponseList;
+
+DT_RespTable::~DT_RespTable()
+{
+	DT_ResponseClass i;
+	for (i = 0; i < m_responseClass; ++i) 
+	{
+		delete [] m_table[i];
+	}
+}
+
+DT_ResponseClass DT_RespTable::genResponseClass()
+{
+	DT_ResponseClass newClass = m_responseClass++;
+	DT_ResponseList *newList = new DT_ResponseList[m_responseClass];
+	assert(newList);
+	m_table.push_back(newList);
+	m_singleList.resize(m_responseClass);
+	DT_ResponseClass i;
+	for (i = 0; i < m_responseClass; ++i) 
+	{
+		newList[i].append(m_default);
+		newList[i].append(m_singleList[i]);
+	}
+	return newClass;
+}
+
+void DT_RespTable::setResponseClass(void *object, 
+									DT_ResponseClass responseClass) 
+{
+	assert(responseClass < m_responseClass);
+	m_objectMap[object] = responseClass;
+}
+
+DT_ResponseClass DT_RespTable::getResponseClass(void *object) const
+{
+	T_ObjectMap::const_iterator it = m_objectMap.find(object);
+	assert(it != m_objectMap.end());
+	return (*it).second;
+}
+
+void DT_RespTable::clearResponseClass(void *object) 
+{
+	m_objectMap.erase(object);
+}
+
+const DT_ResponseList& DT_RespTable::find(void *object1, void *object2) const
+{
+	T_ObjectMap::const_iterator it = m_objectMap.find(object1);
+	if (it != m_objectMap.end()) 
+	{
+		DT_ResponseClass responseClass1 = (*it).second;
+		it = m_objectMap.find(object2);
+		if (it != m_objectMap.end()) 
+		{
+			DT_ResponseClass responseClass2 = (*it).second;
+			if (responseClass1 < responseClass2) 
+			{
+				std::swap(responseClass1, responseClass2);
+			}
+			return m_table[responseClass1][responseClass2];
+		}
+	}
+	return g_emptyResponseList;
+}
+
+void DT_RespTable::addDefault(const DT_Response& response)
+{
+	m_default.addResponse(response);
+	DT_ResponseClass i;
+	for (i = 0; i < m_responseClass; ++i) 
+	{
+		DT_ResponseClass j;
+		for (j = 0; j <= i; ++j) 
+		{
+			m_table[i][j].addResponse(response);
+		}
+	}
+}
+
+void DT_RespTable::removeDefault(const DT_Response& response)
+{
+	m_default.removeResponse(response);
+	DT_ResponseClass i;
+	for (i = 0; i < m_responseClass; ++i) 
+	{
+		DT_ResponseClass j;
+		for (j = 0; j <= i; ++j) 
+		{
+			m_table[i][j].removeResponse(response);
+		}
+	}
+}
+
+void DT_RespTable::addSingle(DT_ResponseClass responseClass, 
+							 const DT_Response& response)
+{	
+	assert(responseClass < m_responseClass);
+	m_singleList[responseClass].addResponse(response);
+	DT_ResponseClass j;
+	for (j = 0; j < responseClass; ++j) 
+	{
+		m_table[responseClass][j].addResponse(response);
+	}
+	
+	DT_ResponseClass i;
+	for (i = responseClass; i < m_responseClass; ++i) 
+	{
+		m_table[i][responseClass].addResponse(response);
+	}
+}
+
+void DT_RespTable::removeSingle(DT_ResponseClass responseClass, 
+								const DT_Response& response)
+{	
+	assert(responseClass < m_responseClass);
+	m_singleList[responseClass].removeResponse(response);
+	DT_ResponseClass j;
+	for (j = 0; j < responseClass; ++j) 
+	{
+		m_table[responseClass][j].removeResponse(response);
+	}
+	
+	DT_ResponseClass i;
+	for (i = responseClass; i < m_responseClass; ++i) 
+	{
+		m_table[i][responseClass].removeResponse(response);
+	}
+}
+
+void DT_RespTable::addPair(DT_ResponseClass responseClass1,
+						   DT_ResponseClass responseClass2, 
+						   const DT_Response& response)
+{
+	assert(responseClass1 < m_responseClass);
+	assert(responseClass2 < m_responseClass);
+	if (responseClass1 < responseClass2) 
+	{
+		std::swap(responseClass1, responseClass2);
+	}
+	m_table[responseClass1][responseClass2].addResponse(response);
+}
+
+
+void DT_RespTable::removePair(DT_ResponseClass responseClass1,
+							  DT_ResponseClass responseClass2, 
+							  const DT_Response& response)
+{
+	assert(responseClass1 < m_responseClass);
+	assert(responseClass2 < m_responseClass);
+	if (responseClass1 < responseClass2) 
+	{
+		std::swap(responseClass1, responseClass2);
+	}
+	m_table[responseClass1][responseClass2].removeResponse(response);
+}
+