updated EventBox

updated Colliding concept (SCENE)
broken Colliding concept (MODEL) outer BBox working only

diff --git a/Weave/Game.cpp b/Weave/Game.cpp
index a8019358924a4b96253a17cc9f18b439ca858d38..e2d586a04e4c38037562d8ce6036a8f9ce50f62b 100644 (file)
--- a/Weave/Game.cpp
+++ b/Weave/Game.cpp
@@ -36,9 +36,6 @@ using std::string;
 
 typedef unsigned int uint;
 
-
-
-
 Game::Game() : playing(true)
 {
        srand((int)time(NULL));

diff --git a/Weave/Graphix/Model/IMesh.cpp b/Weave/Graphix/Model/IMesh.cpp
index 51c14e198e4750500f82819374b534f83434b0c7..75942ee27765e3efadc627961371327174447428 100644 (file)
--- a/Weave/Graphix/Model/IMesh.cpp
+++ b/Weave/Graphix/Model/IMesh.cpp
@@ -147,9 +147,9 @@ bool IMesh::import(const aiMesh* mesh, uint& numvertices, uint& numfaces, float*
        return true;
 }
 
-void IMesh::isColliding(float& _overlap, float& _inside, const Model* _model, const mat4& _modelMatThis, const mat4& _modelMatOther) const
+void IMesh::checkColliding(float& _overlap, float& _inside, const Model* _model, const mat4& _modelMatThis, const mat4& _modelMatOther) const
 {
-       Model::isColliding(_overlap, _inside, _model, _modelMatThis*modelMat, _modelMatOther);
+       Model::checkColliding(_overlap, _inside, _model, _modelMatThis*modelMat, _modelMatOther);
        /* nicht überschneidend also keine weiteren Tests nötig */
        if (_overlap < 0)
                return;

diff --git a/Weave/Graphix/Model/IMesh.h b/Weave/Graphix/Model/IMesh.h
index 781eac9a13acff971ee4a667ed43745b22f2f3cf..c75f7ad9f8302e8ce6378418006feb6ac147ba2f 100644 (file)
--- a/Weave/Graphix/Model/IMesh.h
+++ b/Weave/Graphix/Model/IMesh.h
@@ -26,10 +26,11 @@ public:
        //void bindShader(Shader* shader);
 
        /* calls Colliding to check if self collides with model*/
-       virtual void isColliding(float& overlap, float& inside, const Model* model, const mat4& modelMatThis, const mat4& modelMatOther) const;
+       virtual void checkColliding(float& overlap, float& inside, const Model* model, const mat4& modelMatThis, const mat4& modelMatOther) const;
 
 protected:
 
+
        mat4 modelMat;
 
        // Mesh Speichern?

diff --git a/Weave/Graphix/Model/IMetaMesh.cpp b/Weave/Graphix/Model/IMetaMesh.cpp
index 4cbe1a8d967a5204c534c0c4d14c9a3627c2a4ec..9348c879fad4001c2cd4f7bf032b843de27fa896 100644 (file)
--- a/Weave/Graphix/Model/IMetaMesh.cpp
+++ b/Weave/Graphix/Model/IMetaMesh.cpp
@@ -99,9 +99,9 @@ void IMetaMesh::drawBBox(Shader* _shader, const mat4& _modelMat) const
 }
 
 
-void IMetaMesh::isColliding(float& _overlap, float& _inside, const Model* _model, const mat4& _modelMatThis, const mat4& _modelMatOther) const
+void IMetaMesh::checkColliding(float& _overlap, float& _inside, const Model* _model, const mat4& _modelMatThis, const mat4& _modelMatOther) const
 {
-       Model::isColliding(_overlap, _inside, _model, _modelMatThis, _modelMatOther);
+       Model::checkColliding(_overlap, _inside, _model, _modelMatThis, _modelMatOther);
 
        if (min(_overlap, _inside) >= 0)
        {
@@ -109,7 +109,7 @@ void IMetaMesh::isColliding(float& _overlap, float& _inside, const Model* _model
                float subOverlap = -1, subInside = -1;
                for (auto i = models.begin(); i != models.end(); ++i)
                {
-                       _model->isColliding(subOverlap, subInside, *i, _modelMatThis, _modelMatOther);
+                       _model->checkColliding(subOverlap, subInside, *i, _modelMatThis, _modelMatOther);
                        if (subOverlap > _overlap)
                                _overlap = subOverlap;
                        if (subInside > _inside)

diff --git a/Weave/Graphix/Model/IMetaMesh.h b/Weave/Graphix/Model/IMetaMesh.h
index 9561fd5b141cb1801792f9ef62fec692b1b114a5..5d2b3cb16bad8a1c194f113f64d3fbb77d4b547c 100644 (file)
--- a/Weave/Graphix/Model/IMetaMesh.h
+++ b/Weave/Graphix/Model/IMetaMesh.h
@@ -25,9 +25,10 @@ public:
        void drawBBox(Shader* shader, const mat4& modelMat) const;
 
        /* calls Colliding to check if self collides with model*/
-       void isColliding(float& overlap, float& inside, const Model* model, const mat4& modelMatThis, const mat4& modelMatOther) const;
+       void checkColliding(float& overlap, float& inside, const Model* model, const mat4& modelMatThis, const mat4& modelMatOther) const;
 
 protected:
+
        std::list<IMesh*> models;
 };
 

diff --git a/Weave/Graphix/Model/Model.cpp b/Weave/Graphix/Model/Model.cpp
index af12050ad43777f14ba9b459a084563e59d8f949..0177d8e27a03ca8e56b206422d38a3628440b1ae 100644 (file)
--- a/Weave/Graphix/Model/Model.cpp
+++ b/Weave/Graphix/Model/Model.cpp
@@ -240,7 +240,37 @@ void Model::useModelMat(const mat4& _model, Shader* _shader) const
                glUniformMatrix4fv(tmp, 1, GL_FALSE, value_ptr(_model));
 }
 
-void Model::isColliding(float& _overlap, float& _inside, const Model* _model, const mat4& _modelMatThis, const mat4& _modelMatOther) const
+void Model::isColliding(float& _overlap, float& _inside, const Model* _modelThis, const Model* _modelOther, const mat4& _modelMatThis, const mat4& _modelMatOther)
+{
+       vec3 posA, sizeA, posB, sizeB;
+       float overlap, inside;
+
+       _modelThis->getBBsp(sizeA, posA);
+       _modelOther->getBBsp(sizeB, posB);
+
+       mat4 modelAR = glm::inverse(removeScale(_modelMatOther))*_modelMatThis;
+       mat4 modelBR = glm::inverse(removeScale(_modelMatThis))*_modelMatOther;
+
+       vec3 posAR = (vec3)(modelAR*vec4(posA, 1.f));
+       vec3 posBR = (vec3)(modelBR*vec4(posB, 1.f));
+
+       sizeA /= 2;
+       sizeB /= 2;
+
+       vec3 sizeAR = rotateSize(sizeA, modelAR);
+       vec3 sizeBR = rotateSize(sizeB, modelBR);
+
+       checkCollideByAxis(_overlap, _inside, 3, value_ptr(posAR), value_ptr(posB), value_ptr(sizeAR), value_ptr(sizeB));
+       if (_overlap >= 0)
+       {
+               checkCollideByAxis(overlap, inside, 3, value_ptr(posA), value_ptr(posBR), value_ptr(sizeA), value_ptr(sizeBR));
+               _overlap = min(overlap, _overlap);
+               _inside = min(overlap, _inside);
+       }
+
+}
+
+void Model::checkColliding(float& _overlap, float& _inside, const Model* _model, const mat4& _modelMatThis, const mat4& _modelMatOther) const
 {
        vec3 posA, sizeA, posB, sizeB;
        float overlap, inside;

diff --git a/Weave/Graphix/Model/Model.h b/Weave/Graphix/Model/Model.h
index 672c936f8d9037a93cb8928bbe369af4119e8f59..154c62311f724dc0cec1c894e083ffe59fe5732f 100644 (file)
--- a/Weave/Graphix/Model/Model.h
+++ b/Weave/Graphix/Model/Model.h
@@ -29,7 +29,8 @@ public:
        virtual void getBBsp(vec3& size, vec3& pos) const;
 
        /* calls Colliding to check if self collides with model*/
-       virtual void isColliding(float& overlap, float& inside, const Model* model, const mat4& modelMatThis, const mat4& modelMatOther) const;
+       static void isColliding(float& overlap, float& inside, const Model* modelThis, const Model* modelOther, const mat4& modelMatThis, const mat4& modelMatOther);
+       void checkColliding(float& overlap, float& inside, const Model* model, const mat4& modelMatThis, const mat4& modelMatOther) const;
 
        static Model* getBBoxModel();
 
@@ -55,6 +56,8 @@ protected:
        static Shader* BBoxShader;
        static bool exBBox;
 
+
+
        static vec3 rotateSize(const vec3& size, const mat4& modelMat);
        static void checkCollideByAxis(float& overlap, float& inside, uint dim, const float* posA, const float* posB, const float* sizeA, const float* sizeB);
        static void scaleVec3(vec3& vec, const vec3& scale);

diff --git a/Weave/Scene/EventBox.cpp b/Weave/Scene/EventBox.cpp
index 516f009ed15f864f9cfd84248e8c7a3f1f5120fd..7fd6f96fc94854bb0c064ac0147835e9405d6e66 100644 (file)
--- a/Weave/Scene/EventBox.cpp
+++ b/Weave/Scene/EventBox.cpp
@@ -4,11 +4,15 @@
 #include "../Graphix/Model.h"
 
 #include "../Events.h"
+#include "../Graphix/Texture.h"
 
+#include "../Message.h"
 
-EventBox::EventBox(const mat4& _modelMat) : SceneObject(Graphix::shader_BBox,_modelMat,vec4(0.f),Model::getBBoxModel(),"")
-{
 
+EventBox::EventBox(const mat4& _modelMat, uint _EB_TYPE) : 
+       SceneObject(Graphix::shader_BBox, _modelMat, vec4(0.f), Model::getBBoxModel(), ""), 
+       eb_type(_EB_TYPE)
+{
 }
 
 
@@ -24,4 +28,13 @@ void EventBox::draw() const
 {
        if (Events::isKToggleActive(SDLK_F6))
                model->drawBBox(shader, modelMat);
+}
+
+void EventBox::collides(SceneObject* _other)
+{
+       if ((texture != nullptr && texture->operator std::string() == "model_player_2D.png") || _other->getTexture() != nullptr && (_other->getTexture()->operator std::string() == "model_player_2D.png"))
+       {
+               if (!ignore && !_other->ignore)
+                       Message::info("EB Kollision!" + eb_type);
+       }
 }
\ No newline at end of file

diff --git a/Weave/Scene/EventBox.h b/Weave/Scene/EventBox.h
index 005706a0d7a7dc20e38336577657210cea2795ee..6be1a340f2e4e6abc7613cf655303c778318560c 100644 (file)
--- a/Weave/Scene/EventBox.h
+++ b/Weave/Scene/EventBox.h
@@ -2,17 +2,24 @@
 #include "SceneObject.h"
 
 
-#define EB_WINZONE 1;
-#define EB_LOSTZONE 0;
+#define EB_WINZONE 1
+#define EB_LOSTZONE 2
+
+typedef unsigned int uint;
 
 class EventBox :
        public SceneObject
 {
 public:
-       EventBox(const mat4& modelMat);
+       EventBox(const mat4& modelMat, uint EB_TYPE=0);
        ~EventBox();
 
        virtual void update(float);
        virtual void draw() const;
+       virtual void collides(SceneObject* other);
+
+protected:
+       uint eb_type;
+
 };
 

diff --git a/Weave/Scene/Scene.cpp b/Weave/Scene/Scene.cpp
index a710152d20f921e8a2b9d88eae34ad76b7cd7b7e..aa0034c9b3b643ca7331c2a4ee2ce1eef698af81 100644 (file)
--- a/Weave/Scene/Scene.cpp
+++ b/Weave/Scene/Scene.cpp
@@ -125,7 +125,7 @@ void Scene::update(float deltaT)
                auto j = i;
                for (j++; j != SceneObjects.end(); ++j)
                {
-                       (*i)->collisions(*j);
+                       SceneObject::checkCollision(*i, *j);
                }
        }
 

diff --git a/Weave/Scene/SceneObject.cpp b/Weave/Scene/SceneObject.cpp
index 1a65e9d0eb4a744e7a8246049fd77e7272a3dd8a..769dc3f103566a09c753797cf8d53c6a47462a68 100644 (file)
--- a/Weave/Scene/SceneObject.cpp
+++ b/Weave/Scene/SceneObject.cpp
@@ -136,18 +136,28 @@ void SceneObject::draw() const
                model->drawBBox(shader, modelMat);
 }
 
-void SceneObject::collisions(SceneObject* _other)
+void SceneObject::checkCollision(SceneObject* _first, SceneObject* _second)
 {
-       if (collision_ignore || _other->collision_ignore)
+       if (_first->collision_ignore || _second->collision_ignore)
                return;
 
        float isOverlaping, isInside;
-       model->isColliding(isOverlaping,isInside,_other->model,modelMat,_other->modelMat);
+       Model::isColliding(isOverlaping, isInside, _first->model,_second->model, _first->modelMat, _second->modelMat);
        /* overlapping 1 yes, 0 touch, -1 no*/
        /* inside 1 yes, 0 touch, -1 no*/
+       if (isOverlaping >= 0)
+       {
+               _first->collides(_second);
+               _second->collides(_first);
+       }
+
+}
+
+void SceneObject::collides(SceneObject* _other)
+{
        if ((texture != nullptr && texture->operator std::string() == "model_player_2D.png") || _other->texture != nullptr && (_other->texture->operator std::string() == "model_player_2D.png"))
        {
-               if (isOverlaping >= 0 && (!ignore && !_other->ignore))
+               if (!ignore && !_other->ignore)
                        Message::info("Kollision");
        }
 }
@@ -223,3 +233,8 @@ Shader* SceneObject::getShader() const
 {
        return shader;
 }
+
+Texture* SceneObject::getTexture() const
+{
+       return texture;
+}

diff --git a/Weave/Scene/SceneObject.h b/Weave/Scene/SceneObject.h
index 7e8712bbcf9995b4f328f5d82dd6dfd176df9fb6..80a353ac09430b8e4bc5a6845571bea75845ac67 100644 (file)
--- a/Weave/Scene/SceneObject.h
+++ b/Weave/Scene/SceneObject.h
@@ -26,7 +26,9 @@ public:
        virtual void update(float);
        virtual void draw() const;
 
-       virtual void collisions(SceneObject*);
+       static void checkCollision(SceneObject* first, SceneObject* second);
+
+       virtual void collides(SceneObject* other);
 
        virtual vec3 getPosition() const;
 
@@ -46,6 +48,8 @@ public:
 
        Shader* getShader() const;
 
+       Texture* getTexture() const;
+
        __declspec(deprecated)
        void setEnemy(bool isenemy);
        __declspec(deprecated)