collision_outline.h
1 /*
2 ** ClanLib SDK
3 ** Copyright (c) 1997-2013 The ClanLib Team
4 **
5 ** This software is provided 'as-is', without any express or implied
6 ** warranty. In no event will the authors be held liable for any damages
7 ** arising from the use of this software.
8 **
9 ** Permission is granted to anyone to use this software for any purpose,
10 ** including commercial applications, and to alter it and redistribute it
11 ** freely, subject to the following restrictions:
12 **
13 ** 1. The origin of this software must not be misrepresented; you must not
14 ** claim that you wrote the original software. If you use this software
15 ** in a product, an acknowledgment in the product documentation would be
16 ** appreciated but is not required.
17 ** 2. Altered source versions must be plainly marked as such, and must not be
18 ** misrepresented as being the original software.
19 ** 3. This notice may not be removed or altered from any source distribution.
20 **
21 ** Note: Some of the libraries ClanLib may link to may have additional
22 ** requirements or restrictions.
23 **
24 ** File Author(s):
25 **
26 ** Harry Storbacka
27 ** Magnus Norddahl
28 ** James Wynn
29 ** Emanuel Greisen
30 */
31 
32 
33 #pragma once
34 
35 #include "../api_display.h"
36 #include <vector>
37 #include "contour.h"
38 #include "outline_accuracy.h"
39 #include "../Render/graphic_context.h"
40 #include "../../Core/Resources/xml_resource_node.h"
41 #include "../../Core/Math/cl_math.h"
42 #include "../../Core/Math/origin.h"
43 #include "../../Core/Math/circle.h"
44 #include "../../Core/IOData/file_system.h"
45 #include "../../Core/Resources/resource.h"
46 
47 namespace clan
48 {
51 
52 class CollisionOutline_Impl;
53 class XMLResourceDocument;
54 class OutputSourceProvider;
55 class GraphicContext;
56 class Color;
57 class ResourceManager;
58 class Canvas;
59 
64 {
67 
70 
72  bool is_entry;
73 
76 };
77 
82 {
83  const Contour *contour1;
84  const Contour *contour2;
85  bool inside;
86  std::vector<CollisionPoint> points;
87 
92 
98  CollidingContours(const Contour *c1, const Contour *c2, bool in=false) :
99  contour1(c1),
100  contour2(c2),
101  inside(in),
102  penetration_normal(0.0, 0.0),
103  penetration_depth(0.0),
104  contour1_deep_point(0.0, 0.0),
105  contour2_deep_point(0.0, 0.0)
106  {
107  points.clear();
108  }
109 };
110 
114 class CL_API_DISPLAY CollisionOutline
115 {
118 public:
121 
127  CollisionOutline(const PixelBuffer &pbuf, int alpha_limit=128, OutlineAccuracy accuracy=accuracy_medium );
128 
135  CollisionOutline(const std::string &fullname, int alpha_limit=128, OutlineAccuracy accuracy=accuracy_medium, bool get_insides=true);
136 
144  CollisionOutline(IODevice &file, const std::string &file_extension, int alpha_limit=128, OutlineAccuracy accuracy=accuracy_medium, bool get_insides=true);
145 
153  CollisionOutline(const std::string &filename, const FileSystem &file_system, int alpha_limit=128, OutlineAccuracy accuracy=accuracy_medium, bool get_insides=true);
154 
160  CollisionOutline(const std::vector<Contour> &contours, const Size &size, OutlineAccuracy accuracy);
161 
162  ~CollisionOutline();
165 public:
171  static Resource<CollisionOutline> resource(const std::string &id, const ResourceManager &resources);
172 
174  static CollisionOutline load(const std::string &id, const XMLResourceDocument &doc);
176 
180 public:
182  const Contour &get_object_bounding_box() const;
183 
185 
186  Circlef get_minimum_enclosing_disc() const;
187 
189  bool get_inside_test() const;
190 
192  std::vector<Contour> &get_contours();
193  const std::vector<Contour> &get_contours() const;
194 
196  Pointf get_translation() const;
197 
199  Pointf get_scale() const;
200 
202  float get_angle() const;
203 
205  unsigned int get_width() const;
206 
208  unsigned int get_height() const;
209 
211  void get_alignment( Origin &origin, float &x, float &y ) const;
212 
214  void get_rotation_hotspot( Origin &origin, float &x, float &y) const;
215 
217  const std::vector<CollidingContours> &get_collision_info() const;
218 
220  void get_collision_info_state(bool &points, bool &normals, bool &metadata, bool &pendepth) const;
221 
225 public:
226 
228  CollisionOutline clone() const;
229 
234  void optimize( unsigned char check_distance=3, float corner_angle = PI / 5.0 );
235 
244  void draw(
245  float x,
246  float y,
247  const Colorf &color,
248  Canvas &canvas);
249 
258  void draw_sub_circles(
259  float x,
260  float y,
261  const Colorf &color,
262  Canvas &canvas);
263 
272  void draw_smallest_enclosing_disc(
273  float x,
274  float y,
275  const Colorf &color,
276  Canvas &canvas);
277 
279  void set_alignment( Origin origin, float x=0, float y=0 );
280 
282  void set_rotation_hotspot( Origin origin, float x=0, float y=0 );
283 
285  void set_translation( float x, float y );
286 
288  void set_scale( float x, float y );
289 
291  void set_angle(const Angle &angle);
292 
294  void rotate(const Angle &angle);
295 
297  void set_inside_test( bool value );
298 
300  void enable_collision_info( bool points=true, bool normals=false, bool metadata=false, bool pen_depth=false);
301 
303  void set_collision_info(const std::vector<CollidingContours> &colinfo);
304 
306  void clean_collision_info();
307 
309  void calculate_radius();
310 
312  void calculate_sub_circles(float radius_multiplier=3.5);
313 
315  void calculate_smallest_enclosing_discs();
316 
318  void calculate_convex_hulls();
319 
323  void save(const std::string &fullname) const;
324 
329  void save(const std::string &filename, FileSystem &file_system) const;
330 
334  void save(IODevice &file) const;
335 
340  bool collide( const CollisionOutline &outline, bool remove_old_collision_info=true );
341 
343  static void calculate_penetration_depth(std::vector<CollidingContours> &collision_info);
344 
348  bool point_inside( const Pointf &point ) const;
349 
353 private:
354  std::shared_ptr<CollisionOutline_Impl> impl;
356 };
357 
358 }
359 
Floating point color description class (for float).
Definition: color.h:661
int contour2_line_end
Definition: collision_outline.h:75
Angle class.
Definition: angle.h:63
Resource proxy of a specific type.
Definition: resource.h:59
Pointf normal
Normal vector at the point where the contours intersected.
Definition: collision_outline.h:69
float penetration_depth
Definition: collision_outline.h:89
Pointf point
Coordinates of the point where the contours intersected.
Definition: collision_outline.h:66
2D Graphics Canvas
Definition: canvas.h:70
I/O Device interface.
Definition: iodevice.h:51
const Contour * contour1
Definition: collision_outline.h:83
Definition: outline_accuracy.h:45
Pixel data container.
Definition: pixel_buffer.h:69
Origin
Alignment origins.
Definition: origin.h:41
Strurcture containing information about contours that collided.
Definition: collision_outline.h:81
const float PI
Definition: cl_platform.h:71
CollidingContours(const Contour *c1, const Contour *c2, bool in=false)
Constructs a CollidingContours.
Definition: collision_outline.h:98
bool inside
Definition: collision_outline.h:85
Pointf contour1_deep_point
Definition: collision_outline.h:90
Virtual File System (VFS).
Definition: file_system.h:48
Collision detection contour.
Definition: contour.h:51
Resource manager.
Definition: resource_manager.h:45
Collision detection outline.
Definition: collision_outline.h:114
const Contour * contour2
Definition: collision_outline.h:84
OutlineAccuracy
Outline optimization accuracy.
Definition: outline_accuracy.h:41
Pointf contour2_deep_point
Definition: collision_outline.h:91
int contour2_line_start
Definition: collision_outline.h:75
Circle - Float.
Definition: circle.h:90
std::vector< CollisionPoint > points
Definition: collision_outline.h:86
Pointf penetration_normal
Definition: collision_outline.h:88
2D (width,height) size structure - Integer
Definition: size.h:157
XML Resource Document.
Definition: xml_resource_document.h:49
Collision point information structure.
Definition: collision_outline.h:63
2D (x,y) point structure - Float
Definition: point.h:73
int contour1_line_start
Indexes of intersecting lines on the contours.
Definition: collision_outline.h:75
bool is_entry
Every contour intersection has an entry and exit point. True, if this is an entry point...
Definition: collision_outline.h:72
int contour1_line_end
Definition: collision_outline.h:75