1 /** 2 Base class for all objects affected by physics in 3D space. 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.physicsbody; 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.collisionobject; 24 import godot.spatial; 25 import godot.node; 26 /** 27 Base class for all objects affected by physics in 3D space. 28 29 PhysicsBody is an abstract base class for implementing a physics body. All *Body types inherit from it. 30 */ 31 @GodotBaseClass struct PhysicsBody 32 { 33 package(godot) enum string _GODOT_internal_name = "PhysicsBody"; 34 public: 35 @nogc nothrow: 36 union { /** */ godot_object _godot_object; /** */ CollisionObject _GODOT_base; } 37 alias _GODOT_base this; 38 alias BaseClasses = AliasSeq!(typeof(_GODOT_base), typeof(_GODOT_base).BaseClasses); 39 package(godot) __gshared bool _classBindingInitialized = false; 40 package(godot) static struct GDNativeClassBinding 41 { 42 __gshared: 43 @GodotName("_get_layers") GodotMethod!(long) _getLayers; 44 @GodotName("_set_layers") GodotMethod!(void, long) _setLayers; 45 @GodotName("add_collision_exception_with") GodotMethod!(void, Node) addCollisionExceptionWith; 46 @GodotName("get_collision_exceptions") GodotMethod!(Array) getCollisionExceptions; 47 @GodotName("get_collision_layer") GodotMethod!(long) getCollisionLayer; 48 @GodotName("get_collision_layer_bit") GodotMethod!(bool, long) getCollisionLayerBit; 49 @GodotName("get_collision_mask") GodotMethod!(long) getCollisionMask; 50 @GodotName("get_collision_mask_bit") GodotMethod!(bool, long) getCollisionMaskBit; 51 @GodotName("remove_collision_exception_with") GodotMethod!(void, Node) removeCollisionExceptionWith; 52 @GodotName("set_collision_layer") GodotMethod!(void, long) setCollisionLayer; 53 @GodotName("set_collision_layer_bit") GodotMethod!(void, long, bool) setCollisionLayerBit; 54 @GodotName("set_collision_mask") GodotMethod!(void, long) setCollisionMask; 55 @GodotName("set_collision_mask_bit") GodotMethod!(void, long, bool) setCollisionMaskBit; 56 } 57 /// 58 pragma(inline, true) bool opEquals(in PhysicsBody other) const 59 { return _godot_object.ptr is other._godot_object.ptr; } 60 /// 61 pragma(inline, true) typeof(null) opAssign(typeof(null) n) 62 { _godot_object.ptr = n; return null; } 63 /// 64 pragma(inline, true) bool opEquals(typeof(null) n) const 65 { return _godot_object.ptr is n; } 66 /// 67 size_t toHash() const @trusted { return cast(size_t)_godot_object.ptr; } 68 mixin baseCasts; 69 /// Construct a new instance of PhysicsBody. 70 /// Note: use `memnew!PhysicsBody` instead. 71 static PhysicsBody _new() 72 { 73 static godot_class_constructor constructor; 74 if(constructor is null) constructor = _godot_api.godot_get_class_constructor("PhysicsBody"); 75 if(constructor is null) return typeof(this).init; 76 return cast(PhysicsBody)(constructor()); 77 } 78 @disable new(size_t s); 79 /** 80 81 */ 82 long _getLayers() const 83 { 84 Array _GODOT_args = Array.make(); 85 String _GODOT_method_name = String("_get_layers"); 86 return this.callv(_GODOT_method_name, _GODOT_args).as!(RefOrT!long); 87 } 88 /** 89 90 */ 91 void _setLayers(in long mask) 92 { 93 Array _GODOT_args = Array.make(); 94 _GODOT_args.append(mask); 95 String _GODOT_method_name = String("_set_layers"); 96 this.callv(_GODOT_method_name, _GODOT_args); 97 } 98 /** 99 Adds a body to the list of bodies that this body can't collide with. 100 */ 101 void addCollisionExceptionWith(Node _body) 102 { 103 checkClassBinding!(typeof(this))(); 104 ptrcall!(void)(GDNativeClassBinding.addCollisionExceptionWith, _godot_object, _body); 105 } 106 /** 107 Returns an array of nodes that were added as collision exceptions for this body. 108 */ 109 Array getCollisionExceptions() 110 { 111 checkClassBinding!(typeof(this))(); 112 return ptrcall!(Array)(GDNativeClassBinding.getCollisionExceptions, _godot_object); 113 } 114 /** 115 116 */ 117 long getCollisionLayer() const 118 { 119 checkClassBinding!(typeof(this))(); 120 return ptrcall!(long)(GDNativeClassBinding.getCollisionLayer, _godot_object); 121 } 122 /** 123 Returns an individual bit on the $(D collisionLayer). 124 */ 125 bool getCollisionLayerBit(in long bit) const 126 { 127 checkClassBinding!(typeof(this))(); 128 return ptrcall!(bool)(GDNativeClassBinding.getCollisionLayerBit, _godot_object, bit); 129 } 130 /** 131 132 */ 133 long getCollisionMask() const 134 { 135 checkClassBinding!(typeof(this))(); 136 return ptrcall!(long)(GDNativeClassBinding.getCollisionMask, _godot_object); 137 } 138 /** 139 Returns an individual bit on the $(D collisionMask). 140 */ 141 bool getCollisionMaskBit(in long bit) const 142 { 143 checkClassBinding!(typeof(this))(); 144 return ptrcall!(bool)(GDNativeClassBinding.getCollisionMaskBit, _godot_object, bit); 145 } 146 /** 147 Removes a body from the list of bodies that this body can't collide with. 148 */ 149 void removeCollisionExceptionWith(Node _body) 150 { 151 checkClassBinding!(typeof(this))(); 152 ptrcall!(void)(GDNativeClassBinding.removeCollisionExceptionWith, _godot_object, _body); 153 } 154 /** 155 156 */ 157 void setCollisionLayer(in long layer) 158 { 159 checkClassBinding!(typeof(this))(); 160 ptrcall!(void)(GDNativeClassBinding.setCollisionLayer, _godot_object, layer); 161 } 162 /** 163 Sets individual bits on the $(D collisionLayer) bitmask. Use this if you only need to change one layer's value. 164 */ 165 void setCollisionLayerBit(in long bit, in bool value) 166 { 167 checkClassBinding!(typeof(this))(); 168 ptrcall!(void)(GDNativeClassBinding.setCollisionLayerBit, _godot_object, bit, value); 169 } 170 /** 171 172 */ 173 void setCollisionMask(in long mask) 174 { 175 checkClassBinding!(typeof(this))(); 176 ptrcall!(void)(GDNativeClassBinding.setCollisionMask, _godot_object, mask); 177 } 178 /** 179 Sets individual bits on the $(D collisionMask) bitmask. Use this if you only need to change one layer's value. 180 */ 181 void setCollisionMaskBit(in long bit, in bool value) 182 { 183 checkClassBinding!(typeof(this))(); 184 ptrcall!(void)(GDNativeClassBinding.setCollisionMaskBit, _godot_object, bit, value); 185 } 186 /** 187 The physics layers this area is in. 188 Collidable objects can exist in any of 32 different layers. These layers work like a tagging system, and are not visual. A collidable can use these layers to select with which objects it can collide, using the $(D collisionMask) property. 189 A contact is detected if object A is in any of the layers that object B scans, or object B is in any layer scanned by object A. See $(D url=https://docs.godotengine.org/en/3.3/tutorials/physics/physics_introduction.html#collision-layers-and-masks)Collision layers and masks$(D /url) in the documentation for more information. 190 */ 191 @property long collisionLayer() 192 { 193 return getCollisionLayer(); 194 } 195 /// ditto 196 @property void collisionLayer(long v) 197 { 198 setCollisionLayer(v); 199 } 200 /** 201 The physics layers this area scans for collisions. See $(D url=https://docs.godotengine.org/en/3.3/tutorials/physics/physics_introduction.html#collision-layers-and-masks)Collision layers and masks$(D /url) in the documentation for more information. 202 */ 203 @property long collisionMask() 204 { 205 return getCollisionMask(); 206 } 207 /// ditto 208 @property void collisionMask(long v) 209 { 210 setCollisionMask(v); 211 } 212 }