1 /** 2 Defines a 2D collision polygon. 3 4 Copyright: 5 Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. 6 Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) 7 Copyright (c) 2017-2018 Godot-D contributors 8 9 License: $(LINK2 https://opensource.org/licenses/MIT, MIT License) 10 11 12 */ 13 module godot.collisionpolygon2d; 14 import std.meta : AliasSeq, staticIndexOf; 15 import std.traits : Unqual; 16 import godot.d.traits; 17 import godot.core; 18 import godot.c; 19 import godot.d.bind; 20 import godot.d.reference; 21 import godot.globalenums; 22 import godot.object; 23 import godot.classdb; 24 import godot.node2d; 25 /** 26 Defines a 2D collision polygon. 27 28 Provides a 2D collision polygon to a $(D CollisionObject2D) parent. Polygons can be drawn in the editor or specified by a list of vertices. 29 */ 30 @GodotBaseClass struct CollisionPolygon2D 31 { 32 package(godot) enum string _GODOT_internal_name = "CollisionPolygon2D"; 33 public: 34 @nogc nothrow: 35 union { /** */ godot_object _godot_object; /** */ Node2D _GODOT_base; } 36 alias _GODOT_base this; 37 alias BaseClasses = AliasSeq!(typeof(_GODOT_base), typeof(_GODOT_base).BaseClasses); 38 package(godot) __gshared bool _classBindingInitialized = false; 39 package(godot) static struct GDNativeClassBinding 40 { 41 __gshared: 42 @GodotName("get_build_mode") GodotMethod!(CollisionPolygon2D.BuildMode) getBuildMode; 43 @GodotName("get_one_way_collision_margin") GodotMethod!(double) getOneWayCollisionMargin; 44 @GodotName("get_polygon") GodotMethod!(PoolVector2Array) getPolygon; 45 @GodotName("is_disabled") GodotMethod!(bool) isDisabled; 46 @GodotName("is_one_way_collision_enabled") GodotMethod!(bool) isOneWayCollisionEnabled; 47 @GodotName("set_build_mode") GodotMethod!(void, long) setBuildMode; 48 @GodotName("set_disabled") GodotMethod!(void, bool) setDisabled; 49 @GodotName("set_one_way_collision") GodotMethod!(void, bool) setOneWayCollision; 50 @GodotName("set_one_way_collision_margin") GodotMethod!(void, double) setOneWayCollisionMargin; 51 @GodotName("set_polygon") GodotMethod!(void, PoolVector2Array) setPolygon; 52 } 53 /// 54 pragma(inline, true) bool opEquals(in CollisionPolygon2D other) const 55 { return _godot_object.ptr is other._godot_object.ptr; } 56 /// 57 pragma(inline, true) typeof(null) opAssign(typeof(null) n) 58 { _godot_object.ptr = n; return null; } 59 /// 60 pragma(inline, true) bool opEquals(typeof(null) n) const 61 { return _godot_object.ptr is n; } 62 /// 63 size_t toHash() const @trusted { return cast(size_t)_godot_object.ptr; } 64 mixin baseCasts; 65 /// Construct a new instance of CollisionPolygon2D. 66 /// Note: use `memnew!CollisionPolygon2D` instead. 67 static CollisionPolygon2D _new() 68 { 69 static godot_class_constructor constructor; 70 if(constructor is null) constructor = _godot_api.godot_get_class_constructor("CollisionPolygon2D"); 71 if(constructor is null) return typeof(this).init; 72 return cast(CollisionPolygon2D)(constructor()); 73 } 74 @disable new(size_t s); 75 /// 76 enum BuildMode : int 77 { 78 /** 79 Collisions will include the polygon and its contained area. 80 */ 81 buildSolids = 0, 82 /** 83 Collisions will only include the polygon edges. 84 */ 85 buildSegments = 1, 86 } 87 /// 88 enum Constants : int 89 { 90 buildSolids = 0, 91 buildSegments = 1, 92 } 93 /** 94 95 */ 96 CollisionPolygon2D.BuildMode getBuildMode() const 97 { 98 checkClassBinding!(typeof(this))(); 99 return ptrcall!(CollisionPolygon2D.BuildMode)(GDNativeClassBinding.getBuildMode, _godot_object); 100 } 101 /** 102 103 */ 104 double getOneWayCollisionMargin() const 105 { 106 checkClassBinding!(typeof(this))(); 107 return ptrcall!(double)(GDNativeClassBinding.getOneWayCollisionMargin, _godot_object); 108 } 109 /** 110 111 */ 112 PoolVector2Array getPolygon() const 113 { 114 checkClassBinding!(typeof(this))(); 115 return ptrcall!(PoolVector2Array)(GDNativeClassBinding.getPolygon, _godot_object); 116 } 117 /** 118 119 */ 120 bool isDisabled() const 121 { 122 checkClassBinding!(typeof(this))(); 123 return ptrcall!(bool)(GDNativeClassBinding.isDisabled, _godot_object); 124 } 125 /** 126 127 */ 128 bool isOneWayCollisionEnabled() const 129 { 130 checkClassBinding!(typeof(this))(); 131 return ptrcall!(bool)(GDNativeClassBinding.isOneWayCollisionEnabled, _godot_object); 132 } 133 /** 134 135 */ 136 void setBuildMode(in long build_mode) 137 { 138 checkClassBinding!(typeof(this))(); 139 ptrcall!(void)(GDNativeClassBinding.setBuildMode, _godot_object, build_mode); 140 } 141 /** 142 143 */ 144 void setDisabled(in bool disabled) 145 { 146 checkClassBinding!(typeof(this))(); 147 ptrcall!(void)(GDNativeClassBinding.setDisabled, _godot_object, disabled); 148 } 149 /** 150 151 */ 152 void setOneWayCollision(in bool enabled) 153 { 154 checkClassBinding!(typeof(this))(); 155 ptrcall!(void)(GDNativeClassBinding.setOneWayCollision, _godot_object, enabled); 156 } 157 /** 158 159 */ 160 void setOneWayCollisionMargin(in double margin) 161 { 162 checkClassBinding!(typeof(this))(); 163 ptrcall!(void)(GDNativeClassBinding.setOneWayCollisionMargin, _godot_object, margin); 164 } 165 /** 166 167 */ 168 void setPolygon(in PoolVector2Array polygon) 169 { 170 checkClassBinding!(typeof(this))(); 171 ptrcall!(void)(GDNativeClassBinding.setPolygon, _godot_object, polygon); 172 } 173 /** 174 Collision build mode. Use one of the $(D buildmode) constants. 175 */ 176 @property CollisionPolygon2D.BuildMode buildMode() 177 { 178 return getBuildMode(); 179 } 180 /// ditto 181 @property void buildMode(long v) 182 { 183 setBuildMode(v); 184 } 185 /** 186 If `true`, no collisions will be detected. 187 */ 188 @property bool disabled() 189 { 190 return isDisabled(); 191 } 192 /// ditto 193 @property void disabled(bool v) 194 { 195 setDisabled(v); 196 } 197 /** 198 If `true`, only edges that face up, relative to $(D CollisionPolygon2D)'s rotation, will collide with other objects. 199 */ 200 @property bool oneWayCollision() 201 { 202 return isOneWayCollisionEnabled(); 203 } 204 /// ditto 205 @property void oneWayCollision(bool v) 206 { 207 setOneWayCollision(v); 208 } 209 /** 210 The margin used for one-way collision (in pixels). Higher values will make the shape thicker, and work better for colliders that enter the polygon at a high velocity. 211 */ 212 @property double oneWayCollisionMargin() 213 { 214 return getOneWayCollisionMargin(); 215 } 216 /// ditto 217 @property void oneWayCollisionMargin(double v) 218 { 219 setOneWayCollisionMargin(v); 220 } 221 /** 222 The polygon's list of vertices. The final point will be connected to the first. The returned value is a clone of the $(D PoolVector2Array), not a reference. 223 */ 224 @property PoolVector2Array polygon() 225 { 226 return getPolygon(); 227 } 228 /// ditto 229 @property void polygon(PoolVector2Array v) 230 { 231 setPolygon(v); 232 } 233 }