GraphicsCWLibrary/CollisionModel.cpp at master · Alienturnedhuman/GraphicsCWLibrary · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
//
// Created by Ben Dickson on 5/9/17.
//

#include "CollisionModel.h"
map<string,ConType> CollisionModel::conImport = {{"origin_x",DOUBLE},{"origin_y",DOUBLE},{"box_top",DOUBLE},{"box_bottom",DOUBLE},
                                              {"box_left",DOUBLE},{"box_right",DOUBLE},{"circle_radius",DOUBLE}};

inline CollisionModel::Shape CollisionModel::getModel() const
{
    return model;
}
inline PhysicalModel* CollisionModel::getParentElement() const
{
    return parentElement;
}
inline bool CollisionModel::collidesCC(const CollisionModel &cm) const
{
    // code for Circle/Circle collision here
    Point aPos = this->getGlobalPos();
    Point bPos = cm.getGlobalPos();

    double xDiff = aPos.x - bPos.x;
    double yDiff = aPos.y - bPos.y;
    double rSum = this->getRadius()+cm.getRadius();

    free(&aPos);
    free(&bPos);

    return rSum*rSum < (xDiff*xDiff + yDiff*yDiff);
}
inline bool CollisionModel::collidesCB(const CollisionModel &cm) const
{
    bool rv = false;
    Point o = getGlobalPos();
    Point* rp = cm.getRectPoints();
    rv = CollisionModel::pointInRectangle(o,rp[0],rp[1],rp[2],rp[3]);
    int circIterator = 0;
    double cr = getRadius();
    while(!rv && !(rv = CollisionModel::intersectsCircle(o,cr,rp[circIterator],rp[++circIterator%4])) &&
            circIterator>0){};  // empty while loop, checks and changes occur in condition part
    free(&o);
    free(&rp);
    return rv;
}
inline bool CollisionModel::collidesBB(const CollisionModel &cm) const
{
    bool rv = false;
    Point aO = getGlobalPos();
    Point* aRP = getRectPoints();
    Point bO = cm.getGlobalPos();
    Point* bRP = cm.getRectPoints();

    if(CollisionModel::pointInRectangle(aO,bRP[0],bRP[1],bRP[2],bRP[3]) ||
            CollisionModel::pointInRectangle(bO,aRP[0],aRP[1],aRP[2],aRP[3]))
    {
        rv = true;
    }
    else
    {

    }
    return rv;
}

bool CollisionModel::importDouble(string var,double value)
{
    if(var == "origin_x")
    {
        origin_x = value;
    }
    else if(var == "origin_y")
    {
        origin_y = value;
    }
    else if(var == "box_top")
    {
        box_top = value;
    }
    else if(var == "box_bottom")
    {
        box_bottom = value;
    }
    else if(var == "box_left")
    {
        box_left = value;
    }
    else if(var == "box_right")
    {
        box_right = value;
    }
    else if(var == "circle_radius")
    {
        circle_radius = value;
    }
    else
    {
        return false;
    }
    return true;
}


inline void CollisionPipeline::addModel(CollisionModel* model)
{
    pipeline.push_back(model);
    ++size;
}
inline CollisionModel* CollisionPipeline::nextModel() {
    if (it != pipeline.end()) {
        CollisionModel *r = *it;
        ++it;
    } else {
        return nullptr;
    }
}
inline CollisionModel* CollisionPipeline::popModel()
{
    if(size==0)
    {
        return nullptr;
    }
    CollisionModel* r = pipeline.back();
    pipeline.pop_back();
    --size;
    return r;
}