KiCad PCB EDA Suite
Loading...
Searching...
No Matches
router_preview_item.cpp
Go to the documentation of this file.
1/*
2 * KiRouter - a push-and-(sometimes-)shove PCB router
3 *
4 * Copyright (C) 2013-2014 CERN
5 * Copyright (C) 2016-2023 KiCad Developers, see AUTHORS.txt for contributors.
6 * Author: Tomasz Wlostowski <[email protected]>
7 *
8 * This program is free software: you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation, either version 3 of the License, or (at your
11 * option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22#include <deque>
23#include <gal/color4d.h>
24
26#include <geometry/shape_rect.h>
28#include <pcb_painter.h>
29#include <trigo.h>
30
31#include "router_preview_item.h"
32
33#include "pns_arc.h"
34#include "pns_line.h"
35#include "pns_segment.h"
36#include "pns_via.h"
37
38using namespace KIGFX;
39
40
43 m_view( aView ),
44 m_shape( nullptr ),
45 m_hole( nullptr ),
46 m_flags( aFlags )
47{
48 BOARD_ITEM* boardItem = aItem ? aItem->BoardItem() : nullptr;
49
50 // A PNS::SOLID for an edge-cut item must have 0 width for collision calculations, but when
51 // highlighting an edge we want to show it with its parent PCB_SHAPE's shape.
52 if( boardItem && boardItem->IsOnLayer( Edge_Cuts ) )
53 {
54 m_shape = boardItem->GetEffectiveShape()->Clone();
55 }
56 else if( aItem )
57 {
58 m_shape = aItem->Shape()->Clone();
59
60 if( aItem->Hole() )
61 m_hole = aItem->Hole()->Shape()->Clone();
62 }
63
64 m_clearance = -1;
66
67 m_showClearance = false;
68
69 // initialize variables, overwritten by Update( aItem ), if aItem != NULL
71 m_width = ( aFlags & PNS_SEMI_SOLID ) ? 1 : 0;
73
74 if( aItem )
75 Update( aItem );
76}
77
78
81 m_flags( 0 )
82{
83 m_view = aView;
84
85 m_shape = aShape.Clone();
86 m_hole = nullptr;
87
88 m_clearance = -1;
90
91 m_showClearance = false;
92
93 // initialize variables, overwritten by Update( aItem ), if aItem != NULL
95 m_width = 0;
97}
98
99
101{
102 delete m_shape;
103 delete m_hole;
104}
105
106
108{
109 m_originLayer = aItem->Layers().Start();
110
111 if( const PNS::LINE* l = dyn_cast<const PNS::LINE*>( aItem ) )
112 {
113 if( !l->SegmentCount() )
114 return;
115 }
116 else if( const PNS::VIA* v = dyn_cast<const PNS::VIA*>( aItem ) )
117 {
118 if( v->IsVirtual() )
119 return;
120 }
121
122 assert( m_originLayer >= 0 );
123
126 m_color.a = 0.8;
127 m_depth = m_originDepth - ( ( aItem->Layers().Start() + 1 ) * LayerDepthFactor );
128
129 switch( aItem->Kind() )
130 {
133 m_width = static_cast<const PNS::LINE*>( aItem )->Width();
134 break;
135
136 case PNS::ITEM::ARC_T:
138 m_width = static_cast<const PNS::ARC*>( aItem )->Width();
139 break;
140
143 m_width = static_cast<const PNS::SEGMENT*>( aItem )->Width();
144 break;
145
146 case PNS::ITEM::VIA_T:
149 m_width = 0;
150 m_color = COLOR4D( 0.7, 0.7, 0.7, 0.8 );
152
153 delete m_shape;
154 m_shape = nullptr;
155
156 if( aItem->Shape() )
157 m_shape = aItem->Shape()->Clone();
158
159 delete m_hole;
160 m_hole = nullptr;
161
162 if( aItem->Hole() )
163 m_hole = aItem->Hole()->Shape()->Clone();
164
165 break;
166
169 break;
170
171 default:
172 break;
173 }
174
175 if( aItem->Marker() & PNS::MK_VIOLATION )
177
178 if( m_flags & PNS_COLLISION )
179 m_color = COLOR4D( 0, 1, 0, 1 );
180
181 if( m_flags & PNS_HOVER_ITEM )
182 m_color = m_color.WithAlpha( 1.0 );
183}
184
185
187{
188 BOX2I bbox;
189
190 switch( m_type )
191 {
192 case PR_SHAPE:
193 if( m_shape )
194 {
195 bbox = m_shape->BBox();
196 bbox.Inflate( m_width / 2 );
197 }
198
199 if( m_hole )
200 bbox.Merge( m_hole->BBox() );
201
202 return bbox;
203
204 case PR_POINT:
205 bbox = BOX2I ( m_pos - VECTOR2I( 100000, 100000 ), VECTOR2I( 200000, 200000 ) );
206 return bbox;
207
208 default:
209 break;
210 }
211
212 return bbox;
213}
214
215
217{
218 wxCHECK( aL, /* void */ );
219
220 gal->SetIsFill( false );
221
222 for( int s = 0; s < aL->GetSegmentCount(); s++ )
223 {
224 SEG seg = aL->GetSegment( s );
225
226 if( seg.A == seg.B )
227 {
228 gal->SetIsFill( true );
229 gal->SetIsStroke( false );
230 gal->DrawCircle( seg.A, gal->GetLineWidth() / 2 );
231 gal->SetIsFill( false );
232 gal->SetIsStroke( true );
233 }
234 else
235 {
236 gal->DrawLine( seg.A, seg.B );
237 }
238 }
239
240 const SHAPE_LINE_CHAIN* lineChain = dynamic_cast<const SHAPE_LINE_CHAIN*>( aL );
241
242 for( size_t s = 0; lineChain && s < lineChain->ArcCount(); s++ )
243 {
244 const SHAPE_ARC& arc = lineChain->CArcs()[s];
245 EDA_ANGLE start_angle = arc.GetStartAngle();
246 EDA_ANGLE angle = arc.GetCentralAngle();
247
248 gal->DrawArc( arc.GetCenter(), arc.GetRadius(), start_angle, angle);
249 }
250
251 if( aL->IsClosed() )
252 gal->DrawLine( aL->GetSegment( -1 ).B, aL->GetSegment( 0 ).A );
253}
254
255
256void ROUTER_PREVIEW_ITEM::drawShape( const SHAPE* aShape, KIGFX::GAL* gal ) const
257{
258 bool holeDrawn = false;
259
260 switch( aShape->Type() )
261 {
263 {
264 const SHAPE_LINE_CHAIN_BASE* l = (const SHAPE_LINE_CHAIN_BASE*) aShape;
265
266 if( m_showClearance && m_clearance > 0 )
267 {
268 gal->SetLineWidth( m_width + 2 * m_clearance );
269 drawLineChain( l, gal );
270 }
271
272 gal->SetLayerDepth( m_depth );
273 gal->SetLineWidth( m_width );
274 gal->SetStrokeColor( m_color );
275 gal->SetFillColor( m_color );
276 drawLineChain( l, gal );
277 break;
278 }
279
280 case SH_LINE_CHAIN:
281 {
282 const SHAPE_LINE_CHAIN* l = (const SHAPE_LINE_CHAIN*) aShape;
283 const int w = m_width;
284
285 if( m_showClearance && m_clearance > 0 )
286 {
287 gal->SetLineWidth( w + 2 * m_clearance );
288 drawLineChain( l, gal );
289 }
290
291 gal->SetLayerDepth( m_depth );
292 gal->SetLineWidth( w );
293 gal->SetStrokeColor( m_color );
294 gal->SetFillColor( m_color );
295 drawLineChain( l, gal );
296 break;
297 }
298
299 case SH_SEGMENT:
300 {
301 const SHAPE_SEGMENT* s = (const SHAPE_SEGMENT*) aShape;
302 const int w = s->GetWidth();
303
304 gal->SetIsStroke( false );
305
306 if( m_showClearance && m_clearance > 0 )
307 {
308 gal->SetLineWidth( w + 2 * m_clearance );
309 gal->DrawSegment( s->GetSeg().A, s->GetSeg().B, s->GetWidth() + 2 * m_clearance );
310 }
311
312 gal->SetLayerDepth( m_depth );
313 gal->SetLineWidth( w );
314 gal->SetFillColor( m_color );
315 gal->DrawSegment( s->GetSeg().A, s->GetSeg().B, s->GetWidth() );
316 break;
317 }
318
319 case SH_CIRCLE:
320 {
321 const SHAPE_CIRCLE* c = static_cast<const SHAPE_CIRCLE*>( aShape );
322 gal->SetStrokeColor( m_color );
323
324 if( m_showClearance && m_clearance > 0 )
325 {
326 gal->SetIsStroke( false );
327 gal->DrawCircle( c->GetCenter(), c->GetRadius() + m_clearance );
328 }
329
330 gal->SetLayerDepth( m_depth );
331
332 if( m_hole && dynamic_cast<SHAPE_CIRCLE*>( m_hole ) )
333 {
334 const SHAPE_CIRCLE* h = static_cast<const SHAPE_CIRCLE*>( m_hole );
335 int halfWidth = m_width / 2;
336
337 gal->SetIsStroke( true );
338 gal->SetIsFill( false );
339 gal->SetLineWidth( halfWidth + c->GetRadius() - h->GetRadius() );
340 gal->DrawCircle( c->GetCenter(), ( halfWidth + c->GetRadius() + h->GetRadius() ) / 2 );
341
342 holeDrawn = true;
343 }
344 else
345 {
346 gal->SetIsStroke( m_width ? true : false );
347 gal->SetLineWidth( m_width );
348 gal->SetFillColor( m_color );
349 gal->DrawCircle( c->GetCenter(), c->GetRadius() );
350 }
351
352 break;
353 }
354
355 case SH_RECT:
356 {
357 const SHAPE_RECT* r = (const SHAPE_RECT*) aShape;
358 gal->SetFillColor( m_color );
359
360 if( m_showClearance && m_clearance > 0 )
361 {
362 VECTOR2I p0( r->GetPosition() ), s( r->GetSize() );
363 gal->SetIsStroke( true );
364 gal->SetLineWidth( 2 * m_clearance );
365 gal->DrawLine( p0, VECTOR2I( p0.x + s.x, p0.y ) );
366 gal->DrawLine( p0, VECTOR2I( p0.x, p0.y + s.y ) );
367 gal->DrawLine( p0 + s , VECTOR2I( p0.x + s.x, p0.y ) );
368 gal->DrawLine( p0 + s, VECTOR2I( p0.x, p0.y + s.y ) );
369 }
370
371 gal->SetLayerDepth( m_depth );
372 gal->SetIsStroke( m_width ? true : false );
373 gal->SetLineWidth( m_width);
374 gal->SetStrokeColor( m_color );
375 gal->DrawRectangle( r->GetPosition(), r->GetPosition() + r->GetSize() );
376
377 break;
378 }
379
380 case SH_SIMPLE:
381 {
382 const SHAPE_SIMPLE* c = (const SHAPE_SIMPLE*) aShape;
383 std::deque<VECTOR2D> polygon = std::deque<VECTOR2D>();
384
385 for( int i = 0; i < c->PointCount(); i++ )
386 {
387 polygon.push_back( c->CDPoint( i ) );
388 }
389
390 gal->SetFillColor( m_color );
391
392 if( m_showClearance && m_clearance > 0 )
393 {
394 gal->SetIsStroke( true );
395 gal->SetLineWidth( 2 * m_clearance );
396
397 // need the implicit last segment to be explicit for DrawPolyline
398 polygon.push_back( c->CDPoint( 0 ) );
399 gal->DrawPolyline( polygon );
400 }
401
402 gal->SetLayerDepth( m_depth );
403 gal->SetIsStroke( m_width ? true : false );
404 gal->SetLineWidth( m_width );
405 gal->SetStrokeColor( m_color );
406 gal->DrawPolygon( polygon );
407 break;
408 }
409
410 case SH_ARC:
411 {
412 const SHAPE_ARC* arc = static_cast<const SHAPE_ARC*>( aShape );
413 const int w = arc->GetWidth();
414 EDA_ANGLE start_angle = arc->GetStartAngle();
415 EDA_ANGLE angle = arc->GetCentralAngle();
416
417 gal->SetIsFill( false );
418 gal->SetIsStroke( true );
419
420 if( m_showClearance && m_clearance > 0 )
421 {
422 gal->SetLineWidth( w + 2 * m_clearance );
423 gal->DrawArc( arc->GetCenter(), arc->GetRadius(), start_angle, angle );
424 }
425
426 gal->SetLayerDepth( m_depth );
427 gal->SetStrokeColor( m_color );
428 gal->SetFillColor( m_color );
429 gal->SetLineWidth( w );
430 gal->DrawArc( arc->GetCenter(), arc->GetRadius(), start_angle, angle );
431 break;
432 }
433
434 case SH_COMPOUND:
435 wxFAIL_MSG( wxT( "Router preview item: nested compound shapes not supported" ) );
436 break;
437
438 case SH_POLY_SET:
439 wxFAIL_MSG( wxT( "Router preview item: SHAPE_POLY_SET not supported" ) );
440 break;
441
442 case SH_NULL:
443 break;
444 }
445
446 if( m_hole && !holeDrawn )
447 {
448 gal->SetLayerDepth( m_depth );
449 gal->SetIsStroke( true );
450 gal->SetIsFill( false );
451 gal->SetStrokeColor( m_color );
452 gal->SetLineWidth( 1 );
453
454 SHAPE_CIRCLE* circle = dynamic_cast<SHAPE_CIRCLE*>( m_hole );
455 SHAPE_SEGMENT* slot = dynamic_cast<SHAPE_SEGMENT*>( m_hole );
456
457 if( circle )
458 gal->DrawCircle( circle->GetCenter(), circle->GetRadius() );
459 else if( slot )
460 gal->DrawSegment( slot->GetSeg().A, slot->GetSeg().B, slot->GetWidth() );
461 }
462}
463
464
465void ROUTER_PREVIEW_ITEM::ViewDraw( int aLayer, KIGFX::VIEW* aView ) const
466{
467 GAL* gal = aView->GetGAL();
468 //col.Brighten(0.7);
469
470 if( m_type == PR_SHAPE )
471 {
472 if( !m_shape )
473 return;
474
475 // N.B. The order of draw here is important
476 // Cairo doesn't current support z-ordering, so we need
477 // to draw the clearance first to ensure it is in the background
479
480 //TODO(snh) Add configuration option for the color/alpha here
481 gal->SetStrokeColor( COLOR4D( DARKDARKGRAY ).WithAlpha( 0.9 ) );
482 gal->SetFillColor( COLOR4D( DARKDARKGRAY ).WithAlpha( 0.7 ) );
483 gal->SetIsStroke( m_width ? true : false );
484 gal->SetIsFill( true );
485
486 // Semi-solids (ie: rule areas) which are not in collision are sketched (ie: outline only)
487 if( ( m_flags & PNS_SEMI_SOLID ) > 0 && ( m_flags & PNS_COLLISION ) == 0 )
488 gal->SetIsFill( false );
489
491 {
492 std::vector<const SHAPE*> subshapes;
493 m_shape->GetIndexableSubshapes( subshapes );
494
495 for( const SHAPE* shape : subshapes )
496 drawShape( shape, gal );
497 }
498 else
499 {
500 drawShape( m_shape, gal );
501 }
502 }
503}
504
505
507{
508 auto settings = static_cast<PCB_RENDER_SETTINGS*>( m_view->GetPainter()->GetSettings() );
509
510 COLOR4D color = settings->GetLayerColor( aLayer );
511
512 if( m_flags & PNS_HEAD_TRACE )
513 return color.Saturate( 1.0 );
514 else if( m_flags & PNS_HOVER_ITEM )
515 return color.Brightened( 0.7 );
516
517 return color;
518}
int color
Definition: DXF_plotter.cpp:58
BOX2< VECTOR2I > BOX2I
Definition: box2.h:853
A base class for any item which can be embedded within the BOARD container class, and therefore insta...
Definition: board_item.h:77
virtual bool IsOnLayer(PCB_LAYER_ID aLayer) const
Test to see if this object is on the given layer.
Definition: board_item.h:291
virtual std::shared_ptr< SHAPE > GetEffectiveShape(PCB_LAYER_ID aLayer=UNDEFINED_LAYER, FLASHING aFlash=FLASHING::DEFAULT) const
Some pad shapes can be complex (rounded/chamfered rectangle), even without considering custom shapes.
Definition: board_item.cpp:228
BOX2< Vec > & Inflate(coord_type dx, coord_type dy)
Inflates the rectangle horizontally by dx and vertically by dy.
Definition: box2.h:507
BOX2< Vec > & Merge(const BOX2< Vec > &aRect)
Modify the position and size of the rectangle in order to contain aRect.
Definition: box2.h:589
A base class for most all the KiCad significant classes used in schematics and boards.
Definition: eda_item.h:85
A color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:104
COLOR4D WithAlpha(double aAlpha) const
Return a color with the same color, but the given alpha.
Definition: color4d.h:311
double a
Alpha component.
Definition: color4d.h:379
Abstract interface for drawing on a 2D-surface.
virtual void DrawPolygon(const std::deque< VECTOR2D > &aPointList)
Draw a polygon.
virtual void SetLayerDepth(double aLayerDepth)
Set the depth of the layer (position on the z-axis)
virtual void SetIsFill(bool aIsFillEnabled)
Enable/disable fill.
virtual void DrawRectangle(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a rectangle.
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
virtual void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius)
Draw a circle using world coordinates.
virtual void SetLineWidth(float aLineWidth)
Set the line width.
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList)
Draw a polyline.
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
virtual void SetIsStroke(bool aIsStrokeEnabled)
Enable/disable stroked outlines.
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a line.
virtual void DrawArc(const VECTOR2D &aCenterPoint, double aRadius, const EDA_ANGLE &aStartAngle, const EDA_ANGLE &aAngle)
Draw an arc.
virtual void DrawSegment(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint, double aWidth)
Draw a rounded segment.
float GetLineWidth() const
Get the line width.
virtual RENDER_SETTINGS * GetSettings()=0
Return a pointer to current settings that are going to be used when drawing items.
PCB specific render settings.
Definition: pcb_painter.h:77
Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the...
Definition: view.h:68
int GetLayerOrder(int aLayer) const
Return rendering order of a particular layer.
Definition: view.cpp:643
GAL * GetGAL() const
Return the #GAL this view is using to draw graphical primitives.
Definition: view.h:197
PAINTER * GetPainter() const
Return the painter object used by the view for drawing #VIEW_ITEMS.
Definition: view.h:215
int Start() const
Definition: pns_layerset.h:82
const SHAPE * Shape() const override
Return the geometrical shape of the item.
Definition: pns_hole.h:69
Base class for PNS router board items.
Definition: pns_item.h:97
PnsKind Kind() const
Return the type (kind) of the item.
Definition: pns_item.h:166
virtual const SHAPE * Shape() const
Return the geometrical shape of the item.
Definition: pns_item.h:224
@ SEGMENT_T
Definition: pns_item.h:105
const LAYER_RANGE & Layers() const
Definition: pns_item.h:195
virtual HOLE * Hole() const
Definition: pns_item.h:272
virtual BOARD_ITEM * BoardItem() const
Definition: pns_item.h:190
virtual int Marker() const
Definition: pns_item.h:231
Represents a track on a PCB, connecting two non-trivial joints (that is, vias, pads,...
Definition: pns_line.h:61
ROUTER_PREVIEW_ITEM(const SHAPE &aShape, KIGFX::VIEW *aView=nullptr)
static constexpr double LayerDepthFactor
We draw this item on a single layer, but we stack up all the layers from the various components that ...
void Update(const PNS::ITEM *aItem)
const KIGFX::COLOR4D getLayerColor(int aLayer) const
virtual void ViewDraw(int aLayer, KIGFX::VIEW *aView) const override
Draw the parts of the object belonging to layer aLayer.
void drawLineChain(const SHAPE_LINE_CHAIN_BASE *aL, KIGFX::GAL *aGal) const
const BOX2I ViewBBox() const override
Return the bounding box of the item covering all its layers.
void drawShape(const SHAPE *aShape, KIGFX::GAL *aGal) const
Definition: seg.h:42
VECTOR2I A
Definition: seg.h:49
VECTOR2I B
Definition: seg.h:50
EDA_ANGLE GetCentralAngle() const
Definition: shape_arc.cpp:484
int GetWidth() const
Definition: shape_arc.h:159
double GetRadius() const
Definition: shape_arc.cpp:500
EDA_ANGLE GetStartAngle() const
Definition: shape_arc.cpp:455
VECTOR2I GetCenter() const
Definition: shape_arc.cpp:469
virtual void GetIndexableSubshapes(std::vector< const SHAPE * > &aSubshapes) const
Definition: shape.h:115
virtual bool HasIndexableSubshapes() const
Definition: shape.h:108
SHAPE_TYPE Type() const
Return the type of the shape.
Definition: shape.h:98
int GetRadius() const
Definition: shape_circle.h:108
const VECTOR2I GetCenter() const
Definition: shape_circle.h:113
virtual size_t GetSegmentCount() const =0
virtual bool IsClosed() const =0
virtual const SEG GetSegment(int aIndex) const =0
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
const std::vector< SHAPE_ARC > & CArcs() const
size_t ArcCount() const
const VECTOR2I & GetPosition() const
Definition: shape_rect.h:127
const VECTOR2I GetSize() const
Definition: shape_rect.h:135
const SEG & GetSeg() const
int GetWidth() const
Represent a simple polygon consisting of a zero-thickness closed chain of connected line segments.
Definition: shape_simple.h:42
int PointCount() const
Return the number of points (vertices) in this polygon.
Definition: shape_simple.h:88
const VECTOR2D CDPoint(int aIndex) const
Return a given point as a vector with elements of type double.
Definition: shape_simple.h:113
An abstract shape on 2D plane.
Definition: shape.h:126
virtual SHAPE * Clone() const
Return a dynamically allocated copy of the shape.
Definition: shape.h:148
virtual const BOX2I BBox(int aClearance=0) const =0
Compute a bounding box of the shape, with a margin of aClearance a collision.
@ DARKDARKGRAY
Definition: color4d.h:45
@ LAYER_SELECT_OVERLAY
currently selected items overlay
Definition: layer_ids.h:222
@ LAYER_VIAS
Meta control for all vias opacity/visibility.
Definition: layer_ids.h:196
@ Edge_Cuts
Definition: layer_ids.h:114
@ PCB_LAYER_ID_COUNT
Definition: layer_ids.h:138
The Cairo implementation of the graphics abstraction layer.
Definition: color4d.cpp:247
@ MK_VIOLATION
Definition: pns_item.h:43
#define PNS_HEAD_TRACE
#define PNS_SEMI_SOLID
#define PNS_HOVER_ITEM
#define PNS_COLLISION
@ SH_POLY_SET
set of polygons (with holes, etc.)
Definition: shape.h:52
@ SH_RECT
axis-aligned rectangle
Definition: shape.h:47
@ SH_CIRCLE
circle
Definition: shape.h:50
@ SH_SIMPLE
simple polygon
Definition: shape.h:51
@ SH_NULL
empty shape (no shape...),
Definition: shape.h:55
@ SH_SEGMENT
line segment
Definition: shape.h:48
@ SH_ARC
circular arc
Definition: shape.h:54
@ SH_POLY_SET_TRIANGLE
a single triangle belonging to a POLY_SET triangulation
Definition: shape.h:56
@ SH_LINE_CHAIN
line chain (polyline)
Definition: shape.h:49
@ SH_COMPOUND
compound shape, consisting of multiple simple shapes
Definition: shape.h:53
@ NOT_USED
the 3d code uses this value
Definition: typeinfo.h:79
VECTOR2< int > VECTOR2I
Definition: vector2d.h:588