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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
|
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* $URL$
* $Id$
*
*/
/*
* This code is based on Broken Sword 2.5 engine
*
* Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
*
* Licensed under GNU GPL v2
*
*/
#ifndef SWORD25_REGION_H
#define SWORD25_REGION_H
#include "sword25/kernel/common.h"
#include "sword25/kernel/persistable.h"
#include "sword25/math/vertex.h"
#include "sword25/math/polygon.h"
#include "common/rect.h"
namespace Sword25 {
/**
* This class is the base class of all regions.
*
* The IsValid() method can be queried to see whether the object is in a valid state.
* If this is not the case, the method Init() is the only method that may be invoked.
* This class guarantees that the Vertecies outline of the hole, and the polygons are
* arranged in a clockwise direction, so that the polygon working algorithms will
* work properly.
*/
class Region : public Persistable {
protected:
/**
* Creates a new BS_Region object
*
* After creation the object is invaild (IsValid() return false), but a call can
* be made later on to Init() to set up the region into a valid state.
*/
Region();
Region(InputPersistenceBlock &reader, uint handle);
public:
enum REGION_TYPE {
RT_REGION,
RT_WALKREGION
};
static uint create(REGION_TYPE type);
static uint create(InputPersistenceBlock &reader, uint handle = 0);
virtual ~Region();
/**
* Initialises a BS_Region object
* @param Contour A polygon indicating the outline of the region
* @param pHoles A pointer to an array of polygons representing the hole state in the region.
* If the region has no holes, it must be passed as NULL. The default value is NULL.
* @return Returns true if the initialisation was successful, otherwise false.
* @remark If the region was already initialised, the old state will be deleted.
*/
virtual bool init(const Polygon &contour, const Common::Array<Polygon> *pHoles = NULL);
//
// Exploratory Methods
//
/**
* Specifies whether the object is in a valid state
* @return Returns true if the object is in a valid state, otherwise false.
* @remark Invalid objects can be made valid by calling Init with a valid state.
*/
bool isValid() const {
return _valid;
}
/**
* Returns the position of the region
*/
const Vertex &getPosition() const {
return _position;
}
/**
* Returns the X position of the region
*/
int getPosX() const {
return _position.x;
}
/**
* Returns the Y position of the region
*/
int getPosY() const {
return _position.y;
}
/**
* Indicates whether a point is inside the region
* @param Vertex A verex with the co-ordinates of the test point
* @return Returns true if the point is within the region, otherwise false.
*/
bool isPointInRegion(const Vertex &vertex) const;
/**
* Indicates whether a point is inside the region
* @param X The X position
* @param Y The Y position
* @return Returns true if the point is within the region, otherwise false.
*/
bool isPointInRegion(int x, int y) const;
/**
* Returns the countour of the region
*/
const Polygon &getContour() const {
return _polygons[0];
}
/**
* Returns the number of polygons in the hole region
*/
int getHoleCount() const {
return static_cast<int>(_polygons.size() - 1);
}
/**
* Returns a specific hole polygon in the region
* @param i The number of the hole to return.
* The index must be between 0 and GetHoleCount() - 1.
* @return Returns the desired hole polygon
*/
inline const Polygon &getHole(uint i) const;
/**
* For a point outside the region, finds the closest point inside the region
* @param Point The point that is outside the region
* @return Returns the point within the region which is closest
* @remark This method does not always work with pixel accuracy.
* One should not therefore rely on the fact that there is really no point in
* the region which is closer to the given point.
*/
Vertex findClosestRegionPoint(const Vertex &point) const;
/**
* Returns the centroid for the region
*/
Vertex getCentroid() const;
bool isLineOfSight(const Vertex &a, const Vertex &b) const;
//
// Manipulation Methods
//
/**
* Sets the position of the region
* @param X The new X psoition of the region
* @param Y The new Y psoition of the region
*/
virtual void setPos(int x, int y);
/**
* Sets the X position of the region
* @param X The new X position of the region
*/
void setPosX(int x);
/**
* Sets the Y position of the region
* @param Y The new Y position of the region
*/
void setPosY(int y);
//
// Manipulation Methods
//
virtual bool persist(OutputPersistenceBlock &writer);
virtual bool unpersist(InputPersistenceBlock &reader);
protected:
/// This specifies the type of object
REGION_TYPE _type;
/// This variable indicates whether the current object state is valid
bool _valid;
/// This vertex is the position of the region
Vertex _position;
/// This array contains all the polygons that define the region. The first element of
// the array is the contour, all others are the holes
Common::Array<Polygon> _polygons;
/// The bounding box for the region
Common::Rect _boundingBox;
/**
* Updates the bounding box of the region.
*/
void updateBoundingBox();
/**
* Find the point on a line which is closest to another point
* @param LineStart The start of the line
* @param LineEnd The end of the line
* @param Point The point to be compared against
* @return Returns the point on the line which is cloest to the passed point.
*/
Vertex findClosestPointOnLine(const Vertex &lineStart, const Vertex &lineEnd, const Vertex point) const;
};
inline const Polygon &Region::getHole(uint i) const {
BS_ASSERT(i < _polygons.size() - 1);
return _polygons[i + 1];
}
} // End of namespace Sword25
#endif
|
