/
model.cpp
152 lines (149 loc) · 4.6 KB
/
model.cpp
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
#include "geom2D.hpp"
#include "geom3D.hpp"
namespace boom {
const AMat22 cs_mRot90[2] = {
{spn::COS90, -spn::SIN90,
spn::SIN90, spn::COS90},
{spn::COS90, spn::SIN90,
-spn::SIN90, spn::COS90}
};
float Area_x2(const Vec2& v0, const Vec2& v1) {
return std::fabs(v0.cw(v1));
}
float Area_x2(const Vec3& v0, const Vec3& v1) {
return v0.cross(v1).length();
}
// -------------------------- IModelNode --------------------------
bool IModelNode::imn_refresh(Time_t /*t*/) const {
return true;
}
bool IModelNode::hasInner() const {
return false;
}
bool IModelNode::canCacheShape() const {
return true;
}
void* IModelNode::getCore() {
return this;
}
const void* IModelNode::getCore() const {
return this;
}
void* IModelNode::getUserData() {
return nullptr;
}
std::ostream& operator << (std::ostream& os, const IModelNode& mdl) {
return mdl.print(os);
}
namespace geo3d {
const AMat43 IModel::cs_idMat(AMat43::TagIdentity);
const AMat43& IModel::getToLocalI() const {
auto op = getToLocal();
if(op) return *op;
return cs_idMat;
}
const AMat43& IModel::getToWorldI() const {
auto op = getToWorld();
if(op) return *op;
return cs_idMat;
}
}
namespace geo2d {
MdlItr IModel::getInner() const {
return MdlItr();
}
const AMat32 IModel::cs_idMat(AMat32::TagIdentity);
const AMat32& IModel::getToLocalI() const {
auto op = getToLocal();
if(op) return *op;
return cs_idMat;
}
const AMat32& IModel::getToWorldI() const {
auto op = getToWorld();
if(op) return *op;
return cs_idMat;
}
std::ostream& operator << (std::ostream& os, const IModel& mdl) {
return mdl.print(os);
}
/*
// -------------------------- TModel --------------------------
template <class MDL, class BASE>
TModel<MDL,BASE>::TModel(const MDL &mdl): _model(mdl) {}
#define DEF_TMODEL(typ) template <class MDL,class BASE> typ TModel<MDL,BASE>
DEF_TMODEL(const IModel&)::_getModel(const IModel& mdl) const { return mdl; }
DEF_TMODEL(const IModel&)::_getModel(const HLMdl& mdl) const { return *mdl.cref().get(); }
DEF_TMODEL(Vec2)::support(const Vec2& dir) const {
// dirをローカルに座標変換してサポート写像した後、またワールド座標系に戻す
Vec2 pos = _getModel(_model).support(BASE::toLocalDir(dir));
return BASE::toWorld(pos);
}
DEF_TMODEL(Vec2)::getCenter() const {
Vec2 res = _getModel(_model).getCenter();
return BASE::toWorld(res);
}
DEF_TMODEL(bool)::isInner(const Vec2& pos) const {
Vec2 tpos = BASE::toLocal(pos);
return _getModel(_model).isInner(tpos);
}
DEF_TMODEL(const MDL&)::getModel() const {
return _model;
}
DEF_TMODEL(uint32_t)::getCID() const {
return _getModel(_model).getCID();
}
DEF_TMODEL(Circle)::getBCircle() const {
Circle c = _getModel(_model).bs_getBCircle();
return c * BASE::getToWorld();
}
DEF_TMODEL(float)::getArea(bool bInv) const {
return _getModel(_model).getArea(bInv);
}
DEF_TMODEL(float)::getInertia(bool bInv) const {
// 返すのは常に重心周りの慣性モーメントなので座標変換は不要
return _getModel(_model).getInertia(bInv);
}
DEF_TMODEL(IModel::PosL)::getOverlappingPoints(const IModel& mdl, const Vec2& inner) const {
// innerとmdlをこちらのローカル座標系に変換
TModelR<TR_Mat> t_mdl(mdl, (const BASE&)*this, TR_Mat::TagInverse);
Vec2 t_inner(BASE::toLocal(inner));
// 結果をグローバル座標系へ変換
auto ret = _getModel(_model).getOverlappingPoints(t_mdl, t_inner);
const auto& mat = BASE::getToWorld();
for(auto& p : ret.second)
p = p.asVec3(1) * mat;
return std::move(ret);
}
DEF_TMODEL(int)::getNPoints() const { return _getModel(_model).getNPoints(); }
DEF_TMODEL(Vec2)::getPoint(int n) const {
Vec2 p = _getModel(_model).getPoint(n);
return BASE::toWorld(p);
}
DEF_TMODEL(IModel::CPos)::checkPosition(const Vec2& pos) const {
// posをローカル座標系に変換
Vec2 tpos = BASE::toLocal(pos);
return _getModel(_model).checkPosition(tpos);
}
DEF_TMODEL(Convex2)::splitTwo(const Line& ls) const {
Line tline(BASE::toLocal(ls.pos),
BASE::toLocalDir(ls.dir));
auto res = _getModel(_model).splitTwo(tline);
const auto& mat = BASE::getToWorld();
res.first *= mat;
res.second *= mat;
return std::move(res);
}
DEF_TMODEL(std::ostream&)::dbgPrint(std::ostream& os) const {
int nP = getNPoints();
if(nP > 0) {
for(int i=0 ; i<nP-1 ; i++)
os << getPoint(i) << std::endl;
os << getPoint(nP-1);
}
return os;
}
#undef DEF_TMODEL
template class TModel<HLMdl, TR_Mat>;
template class TModel<const IModel&, TR_Mat>;*/
}
}