- Droping RASSERT_THROW_EXCEPTION and adding classic ASSERT

src/Collision/Plane.cpp

@@ -1,5 +1,5 @@
 #include "Plane.h"
-#include "Exception.h"
+#include "Assert.h"
 
 
 //======================================================================================================================
@@ -14,7 +14,7 @@ void Plane::setFrom3Points(const Vec3& p0, const Vec3& p1, const Vec3& p2)
 	normal = u.cross(v);
 
 	// length of normal had better not be zero
-	RASSERT_THROW_EXCEPTION(isZero(normal.getLengthSquared()));
+	ASSERT(!isZero(normal.getLengthSquared()));
 
 	normal.normalize();
 	offset = normal.dot(p0); // ToDo: correct??
@@ -29,7 +29,7 @@ void Plane::setFromPlaneEquation(float a, float b, float c, float d)
 	// normalize for cheap distance checks
 	float lensq = a * a + b * b + c * c;
 	// length of normal had better not be zero
-	RASSERT_THROW_EXCEPTION(isZero(lensq));
+	ASSERT(!isZero(lensq));
 
 	// recover gracefully
 	if(isZero(lensq))

src/Collision/Sphere.inl.h

@@ -1,6 +1,6 @@
 #include <boost/foreach.hpp>
 #include <boost/range/iterator_range.hpp>
-#include "Exception.h"
+#include "Assert.h"
 
 
 //======================================================================================================================
@@ -9,7 +9,7 @@
 template<typename Container>
 void Sphere::set(const Container& container)
 {
-	RASSERT_THROW_EXCEPTION(container.size() < 1);
+	ASSERT(container.size() >= 1);
 
 	Vec3 min(container.front());
 	Vec3 max(container.front());

src/Core/Object.cpp

@@ -1,5 +1,6 @@
 #include <algorithm>
 #include "Object.h"
+#include "Assert.h"
 #include "Exception.h"
 
 
@@ -39,8 +40,8 @@ Object::~Object()
 //======================================================================================================================
 void Object::addChild(Object* child)
 {
-	RASSERT_THROW_EXCEPTION(child == NULL);
-	RASSERT_THROW_EXCEPTION(child->objParent != NULL); // Child already has parent
+	ASSERT(child != NULL);
+	ASSERT(child->objParent == NULL); // Child already has parent
 
 	child->objParent = this;
 	objChilds.push_back(child);
@@ -52,7 +53,7 @@ void Object::addChild(Object* child)
 //======================================================================================================================
 void Object::removeChild(Object* child)
 {
-	RASSERT_THROW_EXCEPTION(child == NULL);
+	ASSERT(child != NULL);
 
 	Container::iterator it = std::find(objChilds.begin(), objChilds.end(), child);
 

src/Math/Mat3.inl.h

@@ -55,7 +55,7 @@ inline Mat3::Mat3(const Mat3& b)
 // Quat
 inline Mat3::Mat3(const Quat& q)
 {
-	RASSERT_THROW_EXCEPTION(fabs(1.0 - q.getLength()) > 0.002); // If length is > 1 + 0.002 or < 1 - 0.002 then not normalized quat
+	ASSERT(fabs(1.0 - q.getLength()) <= 0.002); // If length is > 1 + 0.002 or < 1 - 0.002 then not normalized quat
 
 	float xs, ys, zs, wx, wy, wz, xx, xy, xz, yy, yz, zz;
 
@@ -107,7 +107,7 @@ inline Mat3::Mat3(const Euler& e)
 // Axisang
 inline Mat3::Mat3(const Axisang& axisang)
 {
-	RASSERT_THROW_EXCEPTION(!isZero(1.0 - axisang.getAxis().getLength())); // Not normalized axis
+	ASSERT(isZero(1.0 - axisang.getAxis().getLength())); // Not normalized axis
 
 	float c, s;
 	sinCos(axisang.getAngle(), s, c);
@@ -760,7 +760,7 @@ inline Mat3 Mat3::getInverse() const
 	float cofactor6 = SELF(0, 1) * SELF(1, 2) - SELF(0, 2) * SELF(1, 1);
 	float det = SELF(0, 0) * cofactor0 + SELF(1, 0) * cofactor3 + SELF(2, 0) * cofactor6;
 
-	RASSERT_THROW_EXCEPTION(isZero(det)); // Cannot invert det == 0
+	ASSERT(!isZero(det)); // Cannot invert det == 0
 
 	// create adjoint matrix and multiply by 1/det to get inverse
 	float invDet = 1.0 / det;

src/Math/Mat4.inl.h

@@ -922,7 +922,7 @@ inline Mat4 Mat4::getInverse() const
 
 		det = SELF(0, 0) * m4(0, 0) + SELF(1, 0) * m4(0, 1) + SELF(2, 0) * m4(0, 2) + SELF(3, 0) * m4(0, 3);
 
-		RASSERT_THROW_EXCEPTION(isZero(det)); // Cannot invert, det == 0
+		ASSERT(!isZero(det)); // Cannot invert, det == 0
 		det = 1.0 / det;
 		m4 *= det;
 		return m4;
@@ -967,8 +967,8 @@ inline Mat4 Mat4::combineTransformations(const Mat4& m0, const Mat4& m1)
 	return Mat4(tra, rot);
 	and the optimized:
 	*/
-	RASSERT_THROW_EXCEPTION(!isZero(m0(3, 0) + m0(3, 1) + m0(3, 2) + m0(3, 3)-1.0) ||
-	          !isZero(m1(3, 0) + m1(3, 1) + m1(3, 2) + m1(3, 3)-1.0)); // one of the 2 mat4 doesnt represent transformation
+	ASSERT(isZero(m0(3, 0) + m0(3, 1) + m0(3, 2) + m0(3, 3)-1.0) &&
+	       isZero(m1(3, 0) + m1(3, 1) + m1(3, 2) + m1(3, 3)-1.0)); // one of the 2 mat4 doesnt represent transformation
 
 	Mat4 m4;
 

src/Math/MathCommon.inl.h

@@ -14,4 +14,4 @@
 #include "MathFuncs.h"
 #include "Transform.h"
 
-#include "Exception.h"
+#include "Assert.h"

src/Math/Quat.inl.h

@@ -275,7 +275,7 @@ inline Quat Quat::getInverted() const
 {
 	float norm = w() * w() + x() * x() + y() * y() + z() * z();
 
-	RASSERT_THROW_EXCEPTION(isZero(norm)); // Norm is zero
+	ASSERT(!isZero(norm)); // Norm is zero
 
 	float normi = 1.0 / norm;
 	return Quat(-normi * x(), -normi * y(), -normi * z(), normi * w());

src/Math/Vec3.inl.h

@@ -335,7 +335,7 @@ inline Vec3 Vec3::getProjection(const Vec3& toThis) const
 // getRotated
 inline Vec3 Vec3::getRotated(const Quat& q) const
 {
-	RASSERT_THROW_EXCEPTION(!isZero(1.0 - q.getLength())); // Not normalized quat
+	ASSERT(isZero(1.0 - q.getLength())); // Not normalized quat
 
 	/*float vmult = 2.0f*(q.x*x + q.y*y + q.z*z);
 	float crossmult = 2.0*q.w;

src/Physics/PhyCharacter.cpp

@@ -21,7 +21,7 @@ PhyCharacter::PhyCharacter(Physics& physics_, const Initializer& init, Object* p
 	motionState = new MotionState(init.startTrf, init.sceneNode, this);
 
 	btAxisSweep3* sweepBp = dynamic_cast<btAxisSweep3*>(physics.broadphase);
-	RASSERT_THROW_EXCEPTION(sweepBp == NULL);
+	ASSERT(sweepBp != NULL);
 
 	ghostPairCallback = new btGhostPairCallback();
 	sweepBp->getOverlappingPairCache()->setInternalGhostPairCallback(ghostPairCallback);

src/Physics/RigidBody.cpp

@@ -12,7 +12,7 @@ RigidBody::RigidBody(Physics& physics_, const Initializer& init, Object* parent)
   Object(parent),
   physics(physics_)
 {
-	RASSERT_THROW_EXCEPTION(init.shape==NULL || init.shape->getShapeType()==INVALID_SHAPE_PROXYTYPE);
+	ASSERT(init.shape != NULL && init.shape->getShapeType() != INVALID_SHAPE_PROXYTYPE);
 
 	bool isDynamic = (init.mass != 0.0);
 

src/Renderer/BufferObjects/BufferObject.cpp

@@ -8,10 +8,10 @@
 //======================================================================================================================
 void BufferObject::create(GLenum target_, uint sizeInBytes_, const void* dataPtr, GLenum usage_)
 {
-	RASSERT_THROW_EXCEPTION(isCreated());
+	ASSERT(!isCreated());
 	// unacceptable usage_
-	RASSERT_THROW_EXCEPTION(usage_ != GL_STREAM_DRAW && usage_ != GL_STATIC_DRAW && usage_ != GL_DYNAMIC_DRAW);
-	RASSERT_THROW_EXCEPTION(sizeInBytes_ < 1); // unacceptable sizeInBytes
+	ASSERT(usage_ == GL_STREAM_DRAW || usage_ == GL_STATIC_DRAW || usage_ == GL_DYNAMIC_DRAW);
+	ASSERT(sizeInBytes_ > 0); // unacceptable sizeInBytes
 
 	usage = usage_;
 	target = target_;
@@ -40,8 +40,8 @@ void BufferObject::create(GLenum target_, uint sizeInBytes_, const void* dataPtr
 //======================================================================================================================
 void BufferObject::write(void* buff)
 {
-	RASSERT_THROW_EXCEPTION(!isCreated());
-	RASSERT_THROW_EXCEPTION(usage == GL_STATIC_DRAW);
+	ASSERT(isCreated());
+	ASSERT(usage != GL_STATIC_DRAW);
 	bind();
 	void* mapped = glMapBuffer(target, GL_WRITE_ONLY);
 	memcpy(mapped, buff, sizeInBytes);
@@ -55,9 +55,9 @@ void BufferObject::write(void* buff)
 //======================================================================================================================
 void BufferObject::write(void* buff, size_t offset, size_t size)
 {
-	RASSERT_THROW_EXCEPTION(!isCreated());
-	RASSERT_THROW_EXCEPTION(usage == GL_STATIC_DRAW);
-	RASSERT_THROW_EXCEPTION(offset + size > sizeInBytes);
+	ASSERT(isCreated());
+	ASSERT(usage != GL_STATIC_DRAW);
+	ASSERT(offset + size <= sizeInBytes);
 	bind();
 	void* mapped = glMapBufferRange(target, offset, size, GL_MAP_WRITE_BIT);
 	memcpy(mapped, buff, size);

src/Renderer/BufferObjects/BufferObject.h

@@ -2,7 +2,7 @@
 #define BUFFER_OBJECT_H
 
 #include <GL/glew.h>
-#include "Exception.h"
+#include "Assert.h"
 #include "StdTypes.h"
 
 
@@ -92,49 +92,49 @@ inline BufferObject::~BufferObject()
 
 inline uint BufferObject::getGlId() const
 {
-	RASSERT_THROW_EXCEPTION(!isCreated());
+	ASSERT(isCreated());
 	return glId;
 }
 
 
 inline GLenum BufferObject::getBufferTarget() const
 {
-	RASSERT_THROW_EXCEPTION(!isCreated());
+	ASSERT(isCreated());
 	return target;
 }
 
 
 inline GLenum BufferObject::getBufferUsage() const
 {
-	RASSERT_THROW_EXCEPTION(!isCreated());
+	ASSERT(isCreated());
 	return usage;
 }
 
 
 inline size_t BufferObject::getSizeInBytes() const
 {
-	RASSERT_THROW_EXCEPTION(!isCreated());
+	ASSERT(isCreated());
 	return sizeInBytes;
 }
 
 
 inline void BufferObject::bind() const
 {
-	RASSERT_THROW_EXCEPTION(!isCreated());
+	ASSERT(isCreated());
 	glBindBuffer(target, glId);
 }
 
 
 inline void BufferObject::unbind() const
 {
-	RASSERT_THROW_EXCEPTION(!isCreated());
+	ASSERT(isCreated());
 	glBindBuffer(target, 0);
 }
 
 
 inline void BufferObject::deleteBuff()
 {
-	RASSERT_THROW_EXCEPTION(!isCreated());
+	ASSERT(isCreated());
 	glDeleteBuffers(1, &glId);
 	glId = 0;
 }

src/Renderer/BufferObjects/Fbo.h

@@ -2,8 +2,9 @@
 #define FBO_H
 
 #include <GL/glew.h>
-#include "Exception.h"
+#include "Assert.h"
 #include "StdTypes.h"
+#include "Exception.h"
 
 
 /// The class is actually a wrapper to avoid common mistakes
@@ -54,14 +55,14 @@ class Fbo
 
 inline void Fbo::create()
 {
-	RASSERT_THROW_EXCEPTION(isCreated());
+	ASSERT(!isCreated());
 	glGenFramebuffers(1, &glId);
 }
 
 
 inline uint Fbo::getGlId() const
 {
-	RASSERT_THROW_EXCEPTION(isCreated());
+	ASSERT(!isCreated());
 	return glId;
 }
 
@@ -77,7 +78,7 @@ inline Fbo::~Fbo()
 
 inline void Fbo::bind() const
 {
-	RASSERT_THROW_EXCEPTION(!isCreated());
+	ASSERT(isCreated());
 	glBindFramebuffer(GL_FRAMEBUFFER, glId);
 }
 
@@ -90,8 +91,8 @@ inline void Fbo::unbind()
 
 inline void Fbo::checkIfGood() const
 {
-	RASSERT_THROW_EXCEPTION(!isCreated());
-	RASSERT_THROW_EXCEPTION(getCurrentFbo() != glId); // another FBO is binded
+	ASSERT(isCreated());
+	ASSERT(getCurrentFbo() == glId); // another FBO is binded
 
 	if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
 	{
@@ -102,8 +103,8 @@ inline void Fbo::checkIfGood() const
 
 inline void Fbo::setNumOfColorAttachements(uint num) const
 {
-	RASSERT_THROW_EXCEPTION(!isCreated());
-	RASSERT_THROW_EXCEPTION(getCurrentFbo() != glId); // another FBO is binded
+	ASSERT(isCreated());
+	ASSERT(getCurrentFbo() == glId); // another FBO is binded
 
 	if(num == 0)
 	{
@@ -117,7 +118,7 @@ inline void Fbo::setNumOfColorAttachements(uint num) const
 			GL_COLOR_ATTACHMENT3, GL_COLOR_ATTACHMENT4, GL_COLOR_ATTACHMENT5,
 			GL_COLOR_ATTACHMENT6, GL_COLOR_ATTACHMENT7};
 
-		RASSERT_THROW_EXCEPTION(num > sizeof(colorAttachments)/sizeof(GLenum));
+		ASSERT(num <= sizeof(colorAttachments) / sizeof(GLenum));
 		glDrawBuffers(num, colorAttachments);
 	}
 }
@@ -133,7 +134,7 @@ inline uint Fbo::getCurrentFbo()
 
 inline void Fbo::destroy()
 {
-	RASSERT_THROW_EXCEPTION(!isCreated());
+	ASSERT(isCreated());
 	glDeleteFramebuffers(1, &glId);
 }
 

src/Renderer/BufferObjects/Vao.cpp

@@ -8,7 +8,7 @@
 void Vao::attachArrayBufferVbo(const Vbo& vbo, uint attribVarLocation, GLint size, GLenum type,
 		                           GLboolean normalized, GLsizei stride, const GLvoid* pointer)
 {
-	RASSERT_THROW_EXCEPTION(!isCreated());
+	ASSERT(isCreated());
 	if(vbo.getBufferTarget() != GL_ARRAY_BUFFER)
 	{
 		throw EXCEPTION("Only GL_ARRAY_BUFFER is accepted");
@@ -42,7 +42,7 @@ void Vao::attachArrayBufferVbo(const Vbo& vbo, const SProgAttribVar& attribVar,
 //======================================================================================================================
 void Vao::attachElementArrayBufferVbo(const Vbo& vbo)
 {
-	RASSERT_THROW_EXCEPTION(!isCreated());
+	ASSERT(isCreated());
 	if(vbo.getBufferTarget() != GL_ELEMENT_ARRAY_BUFFER)
 	{
 		throw EXCEPTION("Only GL_ELEMENT_ARRAY_BUFFER is accepted");

src/Renderer/BufferObjects/Vao.h

@@ -72,7 +72,7 @@ class Vao
 
 inline void Vao::create()
 {
-	RASSERT_THROW_EXCEPTION(isCreated());
+	ASSERT(!isCreated());
 	glGenVertexArrays(1, &glId);
 	ON_GL_FAIL_THROW_EXCEPTION();
 }
@@ -89,14 +89,14 @@ inline Vao::~Vao()
 
 inline void Vao::destroy()
 {
-	RASSERT_THROW_EXCEPTION(!isCreated());
+	ASSERT(isCreated());
 	glDeleteVertexArrays(1, &glId);
 }
 
 
 inline uint Vao::getGlId() const
 {
-	RASSERT_THROW_EXCEPTION(!isCreated());
+	ASSERT(isCreated());
 	return glId;
 }
 

src/Renderer/BufferObjects/Vbo.h

@@ -30,7 +30,7 @@ inline Vbo::Vbo(GLenum target_, uint sizeInBytes_, const void* dataPtr_, GLenum
 
 inline void Vbo::create(GLenum target_, uint sizeInBytes_, const void* dataPtr_, GLenum usage_)
 {
-	RASSERT_THROW_EXCEPTION(target_ != GL_ARRAY_BUFFER && target_ != GL_ELEMENT_ARRAY_BUFFER); // unacceptable target_
+	ASSERT(target_ == GL_ARRAY_BUFFER || target_ == GL_ELEMENT_ARRAY_BUFFER); // unacceptable target_
 	BufferObject::create(target_, sizeInBytes_, dataPtr_, usage_);
 }
 

src/Renderer/Dbg.cpp

@@ -299,7 +299,7 @@ void Dbg::run()
 //======================================================================================================================
 void Dbg::setModelMat(const Mat4& modelMat_)
 {
-	RASSERT_THROW_EXCEPTION(pointIndex != 0); // This means that the func called after begin and before end
+	ASSERT(pointIndex == 0); // This means that the func called after begin and before end
 	modelMat = modelMat_;
 }
 
@@ -309,7 +309,7 @@ void Dbg::setModelMat(const Mat4& modelMat_)
 //======================================================================================================================
 void Dbg::begin()
 {
-	RASSERT_THROW_EXCEPTION(pointIndex != 0);
+	ASSERT(pointIndex == 0);
 }
 
 
@@ -318,7 +318,7 @@ void Dbg::begin()
 //======================================================================================================================
 void Dbg::end()
 {
-	RASSERT_THROW_EXCEPTION(pointIndex == 0);
+	ASSERT(pointIndex != 0);
 
 	positionsVbo.write(&positions[0], 0, sizeof(Vec3) * pointIndex);
 	colorsVbo.write(&colors[0], 0, sizeof(Vec3) * pointIndex);

src/Renderer/Is.cpp

@@ -59,7 +59,7 @@ void Is::calcViewVectors()
 		// end of optimized code
 	}
 
-	RASSERT_THROW_EXCEPTION(sizeof(viewVectors) != viewVectorsVbo.getSizeInBytes());
+	ASSERT(sizeof(viewVectors) == viewVectorsVbo.getSizeInBytes());
 	viewVectorsVbo.write(viewVectors);
 }
 

src/Renderer/SceneDrawer.cpp

@@ -198,7 +198,7 @@ void SceneDrawer::setupShaderProg(const Material& mtl, const Transform& nodeWorl
 							udv.getUniVar().setTexture(r.getPps().getPostPassFai(), textureUnit);
 							break;
 						default:
-							RASSERT_THROW_EXCEPTION("WTF?");
+							ASSERT(0);
 					}
 				}
 				++textureUnit;

src/Renderer/SkinsDeformer.h

@@ -21,12 +21,6 @@ class SkinsDeformer
 			TFSPA_VERT_WEIGHT_WEIGHTS
 		};
 
-		/// @name Accessors
-		/// @{
-		/*const ShaderProg& allSProg() const {return *tfHwSkinningAllSProg;}
-		const ShaderProg& posSProg() const {return *tfHwSkinningAllSProg;}*/
-		/// @}
-
 		void init();
 		void run();
 

src/Renderer/Smo.cpp

@@ -130,7 +130,7 @@ void Smo::run(const SpotLight& light)
 	};
 
 	// render camera shape to stencil buffer
-	RASSERT_THROW_EXCEPTION(sizeof(vertPositions) != cameraPositionsVbo.getSizeInBytes());
+	ASSERT(sizeof(vertPositions) == cameraPositionsVbo.getSizeInBytes());
 	cameraPositionsVbo.write(vertPositions);
 	cameraVao.bind();
 	glDrawElements(GL_TRIANGLES, 6 * 3, GL_UNSIGNED_SHORT, 0);

src/Resources/Core/ResourceManager.inl.h

@@ -1,5 +1,6 @@
 #include "Exception.h"
 #include "Logger.h"
+#include "Assert.h"
 
 
 //======================================================================================================================
@@ -17,14 +18,14 @@ void ResourceManager::allocAndLoadRsrc(const char* filename, Type*& newInstance)
 	}
 	catch(std::exception& e)
 	{
-		ERROR("fuckkkkkkkkkk " << e.what());
+		//ERROR("fuckkkkkkkkkk " << e.what());
 
 		if(newInstance != NULL)
 		{
 			delete newInstance;
 		}
 		
-		throw EXCEPTION(e.what());
+		throw EXCEPTION("Cannot load \"" + filename + "\": " + e.what());
 	}
 }
 
@@ -49,15 +50,29 @@ typename ResourceManager::Types<Type>::Hook& ResourceManager::load(const char* f
 	// else create new, load it and update the container
 	else
 	{
-		typename Types<Type>::Hook* hook = new typename Types<Type>::Hook;
-		hook->uuid = filename;
-		hook->referenceCounter = 1;
-		allocAndLoadRsrc<Type>(filename, hook->resource);
+		typename Types<Type>::Hook* hook = NULL;
 
-		c.push_back(hook);
-		
-		it = c.end();
-		--it;
+		try
+		{
+			hook = new typename Types<Type>::Hook;
+			hook->uuid = filename;
+			hook->referenceCounter = 1;
+			allocAndLoadRsrc<Type>(filename, hook->resource);
+
+			c.push_back(hook);
+
+			it = c.end();
+			--it;
+		}
+		catch(std::exception& e)
+		{
+			if(hook != NULL)
+			{
+				delete hook;
+			}
+
+			throw EXCEPTION("Cannot load \"" + filename + "\": " + e.what());
+		}
 	}
 
 	return *it;
@@ -82,8 +97,8 @@ void ResourceManager::unloadR(const typename Types<Type>::Hook& hook)
 		throw EXCEPTION("Resource hook incorrect (\"" + hook.uuid + "\")");
 	}
 
-	RASSERT_THROW_EXCEPTION(it->uuid != hook.uuid);
-	RASSERT_THROW_EXCEPTION(it->referenceCounter != hook.referenceCounter);
+	ASSERT(it->uuid == hook.uuid);
+	ASSERT(it->referenceCounter == hook.referenceCounter);
 
 	--it->referenceCounter;
 

src/Resources/Core/RsrcAsyncLoadingReqsHandler.cpp

@@ -2,6 +2,7 @@
 #include "Texture.h"
 #include "Logger.h"
 #include "HighRezTimer.h"
+#include "Assert.h"
 
 
 //======================================================================================================================
@@ -36,7 +37,7 @@ void RsrcAsyncLoadingReqsHandler::postProcessFinishedRequests(uint maxTime)
 		}
 
 		LoadingRequestBase& req = requests.front();	
-		RASSERT_THROW_EXCEPTION(filename != req.getFilename());
+		ASSERT(filename == req.getFilename());
 
 		switch(req.getType())
 		{

src/Resources/Core/RsrcPtr.inl.h

@@ -1,5 +1,6 @@
 #include "RsrcPtr.h"
 #include "Exception.h"
+#include "Assert.h"
 
 
 //======================================================================================================================
@@ -22,7 +23,7 @@ RsrcPtr<Type>::RsrcPtr(const RsrcPtr& a):
 template<typename Type>
 Type& RsrcPtr<Type>::operator*() const
 {
-	RASSERT_THROW_EXCEPTION(hook == NULL);
+	ASSERT(hook != NULL);
 	return *hook->resource;
 }
 
@@ -33,7 +34,7 @@ Type& RsrcPtr<Type>::operator*() const
 template<typename Type>
 Type* RsrcPtr<Type>::operator->() const
 {
-	RASSERT_THROW_EXCEPTION(hook == NULL);
+	ASSERT(hook != NULL);
 	return hook->resource;
 }
 
@@ -44,7 +45,7 @@ Type* RsrcPtr<Type>::operator->() const
 template<typename Type>
 void RsrcPtr<Type>::loadRsrc(const char* filename)
 {
-	RASSERT_THROW_EXCEPTION(hook != NULL);
+	ASSERT(hook == NULL);
 	hook = &ResourceManagerSingleton::getInstance().load<Type>(filename);
 }
 
@@ -69,6 +70,6 @@ void RsrcPtr<Type>::unload()
 template<typename Type>
 const std::string& RsrcPtr<Type>::getRsrcName() const
 {
-	RASSERT_THROW_EXCEPTION(hook == NULL);
+	ASSERT(hook != NULL);
 	return hook->uuid;
 }

src/Resources/LightData.h

@@ -54,7 +54,7 @@ class LightData
 
 inline const Texture& LightData::getTexture() const
 {
-	RASSERT_THROW_EXCEPTION(texture.get() == NULL);
+	ASSERT(texture.get() != NULL);
 	return *texture;
 }
 

src/Resources/ParticleEmitterProps.cpp

@@ -1,5 +1,6 @@
 #include <cstring>
 #include "ParticleEmitterProps.h"
+#include "Exception.h"
 
 
 static const char* errMsg = "Incorrect or missing value ";

src/Resources/SProgUniVar.cpp

@@ -11,64 +11,64 @@
 /// - if the current shader program is the var's shader program
 /// - if the GL driver gives the same location as the one the var has
 #define STD_SET_UNI_CHECK() \
-	RASSERT_THROW_EXCEPTION(getLoc() == -1); \
-	RASSERT_THROW_EXCEPTION(ShaderProg::getCurrentProgramGlId() != getFatherSProg().getGlId()); \
-	RASSERT_THROW_EXCEPTION(glGetUniformLocation(getFatherSProg().getGlId(), getName().c_str()) != getLoc());
+	ASSERT(getLoc() != -1); \
+	ASSERT(ShaderProg::getCurrentProgramGlId() == getFatherSProg().getGlId()); \
+	ASSERT(glGetUniformLocation(getFatherSProg().getGlId(), getName().c_str()) == getLoc());
 
 
 void SProgUniVar::setFloat(float f) const
 {
 	STD_SET_UNI_CHECK();
-	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT);
+	ASSERT(getGlDataType() == GL_FLOAT);
 	glUniform1f(getLoc(), f);
 }
 
 void SProgUniVar::setFloatVec(float f[], uint size) const
 {
 	STD_SET_UNI_CHECK();
-	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT);
+	ASSERT(getGlDataType() == GL_FLOAT);
 	glUniform1fv(getLoc(), size, f);
 }
 
 void SProgUniVar::setVec2(const Vec2 v2[], uint size) const
 {
 	STD_SET_UNI_CHECK();
-	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT_VEC2);
+	ASSERT(getGlDataType() == GL_FLOAT_VEC2);
 	glUniform2fv(getLoc(), size, &(const_cast<Vec2&>(v2[0]))[0]);
 }
 
 void SProgUniVar::setVec3(const Vec3 v3[], uint size) const
 {
 	STD_SET_UNI_CHECK();
-	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT_VEC3);
+	ASSERT(getGlDataType() == GL_FLOAT_VEC3);
 	glUniform3fv(getLoc(), size, &(const_cast<Vec3&>(v3[0]))[0]);
 }
 
 void SProgUniVar::setVec4(const Vec4 v4[], uint size) const
 {
 	STD_SET_UNI_CHECK();
-	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT_VEC4);
+	ASSERT(getGlDataType() == GL_FLOAT_VEC4);
 	glUniform4fv(getLoc(), size, &(const_cast<Vec4&>(v4[0]))[0]);
 }
 
 void SProgUniVar::setMat3(const Mat3 m3[], uint size) const
 {
 	STD_SET_UNI_CHECK();
-	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT_MAT3);
+	ASSERT(getGlDataType() == GL_FLOAT_MAT3);
 	glUniformMatrix3fv(getLoc(), size, true, &(m3[0])[0]);
 }
 
 void SProgUniVar::setMat4(const Mat4 m4[], uint size) const
 {
 	STD_SET_UNI_CHECK();
-	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_FLOAT_MAT4);
+	ASSERT(getGlDataType() == GL_FLOAT_MAT4);
 	glUniformMatrix4fv(getLoc(), size, true, &(m4[0])[0]);
 }
 
 void SProgUniVar::setTexture(const Texture& tex, uint texUnit) const
 {
 	STD_SET_UNI_CHECK();
-	RASSERT_THROW_EXCEPTION(getGlDataType() != GL_SAMPLER_2D && getGlDataType() != GL_SAMPLER_2D_SHADOW);
+	ASSERT(getGlDataType() == GL_SAMPLER_2D || getGlDataType() == GL_SAMPLER_2D_SHADOW);
 	tex.bind(texUnit);
 	glUniform1i(getLoc(), texUnit);
 }

src/Resources/ShaderProg.cpp

@@ -67,7 +67,7 @@ uint ShaderProg::createAndCompileShader(const char* sourceCode, const char* prep
 				shaderType = "Fragment shader";
 				break;
 			default:
-				RASSERT_THROW_EXCEPTION(1); // Not supported
+				ASSERT(0); // Not supported
 		}
 		throw SPROG_EXCEPTION(shaderType + " compiler error log follows:\n" + infoLog);
 	}
@@ -189,7 +189,7 @@ void ShaderProg::bindCustomAttribLocs(const ShaderPrePreprocessor& pars) const
 void ShaderProg::load(const char* filename)
 {
 	rsrcFilename = filename;
-	RASSERT_THROW_EXCEPTION(glId != std::numeric_limits<uint>::max());
+	ASSERT(glId == std::numeric_limits<uint>::max());
 
 	ShaderPrePreprocessor pars(filename);
 

src/Resources/ShaderProg.h

@@ -4,7 +4,7 @@
 #include <GL/glew.h>
 #include <limits>
 #include "CharPtrHashMap.h"
-#include "Exception.h"
+#include "Assert.h"
 #include "SProgUniVar.h"
 #include "SProgAttribVar.h"
 #include "Vec.h"
@@ -126,14 +126,14 @@ inline ShaderProg::ShaderProg():
 
 inline GLuint ShaderProg::getGlId() const
 {
-	RASSERT_THROW_EXCEPTION(glId == std::numeric_limits<uint>::max());
+	ASSERT(glId != std::numeric_limits<uint>::max());
 	return glId;
 }
 
 
 inline void ShaderProg::bind() const
 {
-	RASSERT_THROW_EXCEPTION(glId == std::numeric_limits<uint>::max());
+	ASSERT(glId != std::numeric_limits<uint>::max());
 	glUseProgram(glId);
 }
 

src/Resources/Texture.cpp

@@ -129,8 +129,8 @@ void Texture::load(const Image& img)
 void Texture::createEmpty2D(float width_, float height_, int internalFormat, int format_, uint type_)
 {
 	target = GL_TEXTURE_2D;
-	RASSERT_THROW_EXCEPTION(internalFormat > 0 && internalFormat <= 4); // deprecated internal format
-	RASSERT_THROW_EXCEPTION(isLoaded());
+	ASSERT(internalFormat <= 0 || internalFormat > 4); // deprecated internal format
+	ASSERT(!isLoaded());
 
 	// GL stuff
 	glGenTextures(1, &glId);
@@ -153,7 +153,7 @@ void Texture::createEmpty2D(float width_, float height_, int internalFormat, int
 void Texture::createEmpty2DMsaa(int samplesNum, int internalFormat, int width_, int height_, bool mimapping)
 {
 	target = GL_TEXTURE_2D_MULTISAMPLE;
-	RASSERT_THROW_EXCEPTION(isLoaded());
+	ASSERT(!isLoaded());
 
 	glGenTextures(1, &glId);
 	bind(LAST_TEX_UNIT);

src/Resources/Texture.h

@@ -3,7 +3,7 @@
 
 #include <limits>
 #include "StdTypes.h"
-#include "Exception.h"
+#include "Assert.h"
 
 
 class Image;
@@ -87,7 +87,7 @@ class Texture
 
 inline uint Texture::getGlId() const
 {
-	RASSERT_THROW_EXCEPTION(!isLoaded());
+	ASSERT(isLoaded());
 	return glId;
 }
 

src/Scene/Controllers/SkelAnimModelNodeCtrl.cpp

@@ -23,7 +23,7 @@ SkelAnimModelNodeCtrl::SkelAnimModelNodeCtrl(SkinNode& skinNode_):
 void SkelAnimModelNodeCtrl::interpolate(const SkelAnim& animation, float frame,
                                         Vec<Vec3>& boneTranslations, Vec<Mat3>& boneRotations)
 {
-	RASSERT_THROW_EXCEPTION(frame >= animation.framesNum);
+	ASSERT(frame < animation.framesNum);
 
 	// calculate the t (used in slerp and lerp) using the keyframs and the frame and
 	// calc the lPose and rPose witch indicate the pose ids in witch the frame lies between
@@ -48,7 +48,7 @@ void SkelAnimModelNodeCtrl::interpolate(const SkelAnim& animation, float frame,
 	}
 
 	// now for all bones update bone's poses
-	RASSERT_THROW_EXCEPTION(boneRotations.size() < 1);
+	ASSERT(boneRotations.size() >= 1);
 	for(uint i=0; i<boneRotations.size(); i++)
 	{
 		const SkelAnim::BoneAnim& banim = animation.bones[i];

src/Scene/Scene.cpp

@@ -93,14 +93,14 @@ void Scene::unregisterNode(SceneNode* node)
 //======================================================================================================================
 void Scene::registerController(Controller* controller)
 {
-	RASSERT_THROW_EXCEPTION(std::find(controllers.begin(), controllers.end(), controller) != controllers.end());
+	ASSERT(std::find(controllers.begin(), controllers.end(), controller) == controllers.end());
 	controllers.push_back(controller);
 }
 
 void Scene::unregisterController(Controller* controller)
 {
 	Vec<Controller*>::iterator it = std::find(controllers.begin(), controllers.end(), controller);
-	RASSERT_THROW_EXCEPTION(it == controllers.end());
+	ASSERT(it != controllers.end());
 	controllers.erase(it);
 }
 
@@ -110,7 +110,7 @@ void Scene::unregisterController(Controller* controller)
 //======================================================================================================================
 void Scene::updateAllWorldStuff()
 {
-	RASSERT_THROW_EXCEPTION(nodes.size() > 1024);
+	ASSERT(nodes.size() <= 1024);
 	boost::array<SceneNode*, 1024> queue;
 	uint head = 0, tail = 0;
 	uint num = 0;
@@ -143,7 +143,7 @@ void Scene::updateAllWorldStuff()
 		}
 	}
 
-	RASSERT_THROW_EXCEPTION(num != nodes.size());
+	ASSERT(num == nodes.size());
 }
 
 

src/Scene/Scene.h

@@ -3,7 +3,7 @@
 
 #include <memory>
 #include "Physics.h"
-#include "Exception.h"
+#include "Assert.h"
 #include "Properties.h"
 #include "Singleton.h"
 #include "VisibilityTester.h"
@@ -89,7 +89,7 @@ class Scene
 template<typename ContainerType, typename Type>
 inline void Scene::putBackNode(ContainerType& container, Type* x)
 {
-	RASSERT_THROW_EXCEPTION(std::find(container.begin(), container.end(), x) != container.end());
+	ASSERT(std::find(container.begin(), container.end(), x) == container.end());
 	container.push_back(x);
 }
 
@@ -98,7 +98,7 @@ template<typename ContainerType, typename Type>
 inline void Scene::eraseNode(ContainerType& container, Type* x)
 {
 	typename ContainerType::iterator it = std::find(container.begin(), container.end(), x);
-	RASSERT_THROW_EXCEPTION(it == container.end());
+	ASSERT(it != container.end());
 	container.erase(it);
 }
 

src/Scene/SkinNode.cpp

@@ -16,3 +16,13 @@ void SkinNode::init(const char* filename)
 		patches.push_back(new SkinPatchNode(patch, this));
 	}
 }
+
+
+//======================================================================================================================
+// updateTrf                                                                                                           =
+//======================================================================================================================
+void SkinNode::updateTrf()
+{
+	boundingShapeWSpace.set(tails);
+	boundingShapeWSpace = boundingShapeWSpace.getTransformed(worldTransform);
+}

src/Scene/SkinNode.h

@@ -34,13 +34,19 @@ class SkinNode: public SceneNode
 		Vec<Vec3>& getBoneTranslations() {return boneTranslations;}
 
 		const Skin& getSkin() const {return *skin;}
+
+		const Sphere& getBoundingShapeWSpace() const {return boundingShapeWSpace;}
 		/// @}
 
 		void init(const char* filename);
 
+		/// Update boundingShapeWSpace from bone tails (not bone and heads cause its faster that way)
+		void updateTrf();
+
 	private:
 		RsrcPtr<Skin> skin; ///< The resource
 		Vec<SkinPatchNode*> patches;
+		Sphere boundingShapeWSpace;
 
 		Vec<Vec3> heads;
 		Vec<Vec3> tails;

src/Scene/SkinPatchNode.cpp

@@ -60,7 +60,7 @@ SkinPatchNode::SkinPatchNode(const ModelPatch& modelPatch, SkinNode* parent):
 	}
 
 	// Attach some extra stuff to the tfVao
-	RASSERT_THROW_EXCEPTION(!mesh.getVbo(Mesh::VBO_VERT_WEIGHTS).isCreated());
+	ASSERT(mesh.getVbo(Mesh::VBO_VERT_WEIGHTS).isCreated());
 
 	tfVao.attachArrayBufferVbo(mesh.getVbo(Mesh::VBO_VERT_WEIGHTS), SkinsDeformer::TFSPA_VERT_WEIGHT_BONES_NUM, 1,
 	                           GL_FLOAT, GL_FALSE, sizeof(MeshData::VertexWeight), BUFFER_OFFSET(0));

src/Util/Assert.h

@@ -0,0 +1,22 @@
+#ifndef ASSERT_H
+#define ASSERT_H
+
+#include <iostream>
+#include <cstdlib>
+
+
+/// Assertion. Print an error and stop the debugger and then abort
+#if DEBUG_ENABLED == 1
+	#define ASSERT(x) \
+		if(!(x)) { \
+			std::cerr << "(" << __FILE__ << ":" << __LINE__ << " " << __PRETTY_FUNCTION__ << ") " << \
+			             "Assertion failed: " << #x << std::endl; \
+			asm("int $3"); \
+			abort(); \
+		}
+#else
+	#define ASSERT(x) ((void)0)
+#endif
+
+
+#endif

src/Util/Exception.h

@@ -35,14 +35,5 @@ class Exception: public std::exception
 
 #define EXCEPTION(x) Exception(std::string() + x, __FILE__, __LINE__, __PRETTY_FUNCTION__)
 
-#if DEBUG_ENABLED == 1
-	#define RASSERT_THROW_EXCEPTION(x) \
-		if(x) \
-			throw EXCEPTION("Reverse assertion failed: " #x)
-#else
-	#define RASSERT_THROW_EXCEPTION(x)
-#endif
-
-
 
 #endif

src/Util/HighRezTimer.cpp

@@ -1,6 +1,6 @@
 #include <boost/date_time/posix_time/posix_time.hpp>
 #include "HighRezTimer.h"
-#include "Exception.h"
+#include "Assert.h"
 
 
 //======================================================================================================================
@@ -17,8 +17,8 @@ HighRezTimer::HighRezTimer():
 //======================================================================================================================
 void HighRezTimer::start()
 {
-	RASSERT_THROW_EXCEPTION(startTime != 0);
-	RASSERT_THROW_EXCEPTION(stopTime != 0);
+	ASSERT(startTime == 0);
+	ASSERT(stopTime == 0);
 	startTime = getCrntTime();
 	stopTime = 0;
 }
@@ -29,8 +29,8 @@ void HighRezTimer::start()
 //======================================================================================================================
 void HighRezTimer::stop()
 {
-	RASSERT_THROW_EXCEPTION(startTime == 0);
-	RASSERT_THROW_EXCEPTION(stopTime != 0);
+	ASSERT(startTime != 0);
+	ASSERT(stopTime == 0);
 	stopTime = getCrntTime();
 }
 

src/Util/Scanner.cpp

@@ -4,9 +4,10 @@
 #include <cmath>
 #include <sstream>
 #include <iomanip>
+#include <boost/lexical_cast.hpp>
 #include "Scanner.h"
 #include "Exception.h"
-#include <boost/lexical_cast.hpp>
+#include "Assert.h"
 
 
 #define SCANNER_EXCEPTION(x) \
@@ -214,7 +215,7 @@ void Scanner::getLine()
 		++lineNmbr;
 	}
 
-	RASSERT_THROW_EXCEPTION(inStream->gcount() > MAX_SCRIPT_LINE_LEN - 10); // too big line
+	ASSERT(inStream->gcount() <= MAX_SCRIPT_LINE_LEN - 10); // too big line
 }
 
 
@@ -301,7 +302,7 @@ void Scanner::loadIstream(std::istream& istream_, const char* scriptName_)
 	inStream = &istream_;
 
 	// init globals
-	RASSERT_THROW_EXCEPTION(strlen(scriptName_) > sizeof(scriptName) / sizeof(char) - 1); // Too big name
+	ASSERT(strlen(scriptName_) <= sizeof(scriptName) / sizeof(char) - 1); // Too big name
 	crntToken.code = TC_ERROR;
 	lineNmbr = 0;
 	strcpy(scriptName, scriptName_);

src/Util/Vec.h

@@ -2,7 +2,7 @@
 #define VEC_H
 
 #include <vector>
-#include "Exception.h"
+#include "Assert.h"
 
 
 /// This is a wrapper of std::std::vector that adds new functionality
@@ -53,7 +53,7 @@ Vec<Type>::Vec(size_t size, Type val):
 template<typename Type>
 Type& Vec<Type>::operator[](size_t n)
 {
-	RASSERT_THROW_EXCEPTION(n >= std::vector<Type>::size());
+	ASSERT(n < std::vector<Type>::size());
 	return std::vector<Type>::operator [](n);
 }
 
@@ -64,7 +64,7 @@ Type& Vec<Type>::operator[](size_t n)
 template<typename Type>
 const Type& Vec<Type>::operator[](size_t n) const
 {
-	RASSERT_THROW_EXCEPTION(n >= std::vector<Type>::size());
+	ASSERT(n < std::vector<Type>::size());
 	return std::vector<Type>::operator [](n);
 }